! function(e, t) {
	"object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define &&
		define.amd ? define(t) : (e = e || self).polyv = t()
}(this, function() {
	"use strict";
	var commonjsGlobal = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" !=
		typeof self ? self : {};

	function commonjsRequire() {
		throw new Error("Dynamic requires are not currently supported by rollup-plugin-commonjs")
	}

	function createCommonjsModule(e, t) {
		return e(t = {
			exports: {}
		}, t.exports), t.exports
	}
	var regeneratorRuntime = createCommonjsModule(function(e) {
		! function(t) {
			var r, n = Object.prototype,
				i = n.hasOwnProperty,
				o = "function" == typeof Symbol ? Symbol : {},
				a = o.iterator || "@@iterator",
				u = o.asyncIterator || "@@asyncIterator",
				s = o.toStringTag || "@@toStringTag",
				f = t.regeneratorRuntime;
			if (f) e.exports = f;
			else {
				(f = t.regeneratorRuntime = e.exports).wrap = b;
				var l = "suspendedStart",
					c = "suspendedYield",
					d = "executing",
					h = "completed",
					p = {},
					_ = {};
				_[a] = function() {
					return this
				};
				var m = Object.getPrototypeOf,
					y = m && m(m(O([])));
				y && y !== n && i.call(y, a) && (_ = y);
				var g = w.prototype = A.prototype = Object.create(_);
				T.prototype = g.constructor = w, w.constructor = T, w[s] = T.displayName = "GeneratorFunction", f.isGeneratorFunction =
					function(e) {
						var t = "function" == typeof e && e.constructor;
						return !!t && (t === T || "GeneratorFunction" === (t.displayName || t.name))
					}, f.mark = function(e) {
						return Object.setPrototypeOf ? Object.setPrototypeOf(e, w) : (e.__proto__ = w, s in e || (e[s] =
							"GeneratorFunction")), e.prototype = Object.create(g), e
					}, f.awrap = function(e) {
						return {
							__await: e
						}
					}, E(M.prototype), M.prototype[u] = function() {
						return this
					}, f.AsyncIterator = M, f.async = function(e, t, r, n) {
						var i = new M(b(e, t, r, n));
						return f.isGeneratorFunction(t) ? i : i.next().then(function(e) {
							return e.done ? e.value : i.next()
						})
					}, E(g), g[s] = "Generator", g[a] = function() {
						return this
					}, g.toString = function() {
						return "[object Generator]"
					}, f.keys = function(e) {
						var t = [];
						for (var r in e) t.push(r);
						return t.reverse(),
							function r() {
								for (; t.length;) {
									var n = t.pop();
									if (n in e) return r.value = n, r.done = !1, r
								}
								return r.done = !0, r
							}
					}, f.values = O, I.prototype = {
						constructor: I,
						reset: function(e) {
							if (this.prev = 0, this.next = 0, this.sent = this._sent = r, this.done = !1, this.delegate = null, this.method =
								"next", this.arg = r, this.tryEntries.forEach(R), !e)
								for (var t in this) "t" === t.charAt(0) && i.call(this, t) && !isNaN(+t.slice(1)) && (this[t] = r)
						},
						stop: function() {
							this.done = !0;
							var e = this.tryEntries[0].completion;
							if ("throw" === e.type) throw e.arg;
							return this.rval
						},
						dispatchException: function(e) {
							if (this.done) throw e;
							var t = this;

							function n(n, i) {
								return u.type = "throw", u.arg = e, t.next = n, i && (t.method = "next", t.arg = r), !!i
							}
							for (var o = this.tryEntries.length - 1; o >= 0; --o) {
								var a = this.tryEntries[o],
									u = a.completion;
								if ("root" === a.tryLoc) return n("end");
								if (a.tryLoc <= this.prev) {
									var s = i.call(a, "catchLoc"),
										f = i.call(a, "finallyLoc");
									if (s && f) {
										if (this.prev < a.catchLoc) return n(a.catchLoc, !0);
										if (this.prev < a.finallyLoc) return n(a.finallyLoc)
									} else if (s) {
										if (this.prev < a.catchLoc) return n(a.catchLoc, !0)
									} else {
										if (!f) throw new Error("try statement without catch or finally");
										if (this.prev < a.finallyLoc) return n(a.finallyLoc)
									}
								}
							}
						},
						abrupt: function(e, t) {
							for (var r = this.tryEntries.length - 1; r >= 0; --r) {
								var n = this.tryEntries[r];
								if (n.tryLoc <= this.prev && i.call(n, "finallyLoc") && this.prev < n.finallyLoc) {
									var o = n;
									break
								}
							}
							o && ("break" === e || "continue" === e) && o.tryLoc <= t && t <= o.finallyLoc && (o = null);
							var a = o ? o.completion : {};
							return a.type = e, a.arg = t, o ? (this.method = "next", this.next = o.finallyLoc, p) : this.complete(a)
						},
						complete: function(e, t) {
							if ("throw" === e.type) throw e.arg;
							return "break" === e.type || "continue" === e.type ? this.next = e.arg : "return" === e.type ? (this.rval =
									this.arg = e.arg, this.method = "return", this.next = "end") : "normal" === e.type && t && (this.next = t),
								p
						},
						finish: function(e) {
							for (var t = this.tryEntries.length - 1; t >= 0; --t) {
								var r = this.tryEntries[t];
								if (r.finallyLoc === e) return this.complete(r.completion, r.afterLoc), R(r), p
							}
						},
						catch: function(e) {
							for (var t = this.tryEntries.length - 1; t >= 0; --t) {
								var r = this.tryEntries[t];
								if (r.tryLoc === e) {
									var n = r.completion;
									if ("throw" === n.type) {
										var i = n.arg;
										R(r)
									}
									return i
								}
							}
							throw new Error("illegal catch attempt")
						},
						delegateYield: function(e, t, n) {
							return this.delegate = {
								iterator: O(e),
								resultName: t,
								nextLoc: n
							}, "next" === this.method && (this.arg = r), p
						}
					}
			}

			function b(e, t, r, n) {
				var i = t && t.prototype instanceof A ? t : A,
					o = Object.create(i.prototype),
					a = new I(n || []);
				return o._invoke = function(e, t, r) {
					var n = l;
					return function(i, o) {
						if (n === d) throw new Error("Generator is already running");
						if (n === h) {
							if ("throw" === i) throw o;
							return P()
						}
						for (r.method = i, r.arg = o;;) {
							var a = r.delegate;
							if (a) {
								var u = S(a, r);
								if (u) {
									if (u === p) continue;
									return u
								}
							}
							if ("next" === r.method) r.sent = r._sent = r.arg;
							else if ("throw" === r.method) {
								if (n === l) throw n = h, r.arg;
								r.dispatchException(r.arg)
							} else "return" === r.method && r.abrupt("return", r.arg);
							n = d;
							var s = v(e, t, r);
							if ("normal" === s.type) {
								if (n = r.done ? h : c, s.arg === p) continue;
								return {
									value: s.arg,
									done: r.done
								}
							}
							"throw" === s.type && (n = h, r.method = "throw", r.arg = s.arg)
						}
					}
				}(e, r, a), o
			}

			function v(e, t, r) {
				try {
					return {
						type: "normal",
						arg: e.call(t, r)
					}
				} catch (e) {
					return {
						type: "throw",
						arg: e
					}
				}
			}

			function A() {}

			function T() {}

			function w() {}

			function E(e) {
				["next", "throw", "return"].forEach(function(t) {
					e[t] = function(e) {
						return this._invoke(t, e)
					}
				})
			}

			function M(e) {
				function t(r, n, o, a) {
					var u = v(e[r], e, n);
					if ("throw" !== u.type) {
						var s = u.arg,
							f = s.value;
						return f && "object" == typeof f && i.call(f, "__await") ? Promise.resolve(f.__await).then(function(e) {
							t("next", e, o, a)
						}, function(e) {
							t("throw", e, o, a)
						}) : Promise.resolve(f).then(function(e) {
							s.value = e, o(s)
						}, a)
					}
					a(u.arg)
				}
				var r;
				this._invoke = function(e, n) {
					function i() {
						return new Promise(function(r, i) {
							t(e, n, r, i)
						})
					}
					return r = r ? r.then(i, i) : i()
				}
			}

			function S(e, t) {
				var n = e.iterator[t.method];
				if (n === r) {
					if (t.delegate = null, "throw" === t.method) {
						if (e.iterator.return && (t.method = "return", t.arg = r, S(e, t), "throw" === t.method)) return p;
						t.method = "throw", t.arg = new TypeError("The iterator does not provide a 'throw' method")
					}
					return p
				}
				var i = v(n, e.iterator, t.arg);
				if ("throw" === i.type) return t.method = "throw", t.arg = i.arg, t.delegate = null, p;
				var o = i.arg;
				return o ? o.done ? (t[e.resultName] = o.value, t.next = e.nextLoc, "return" !== t.method && (t.method = "next",
					t.arg = r), t.delegate = null, p) : o : (t.method = "throw", t.arg = new TypeError(
					"iterator result is not an object"), t.delegate = null, p)
			}

			function k(e) {
				var t = {
					tryLoc: e[0]
				};
				1 in e && (t.catchLoc = e[1]), 2 in e && (t.finallyLoc = e[2], t.afterLoc = e[3]), this.tryEntries.push(t)
			}

			function R(e) {
				var t = e.completion || {};
				t.type = "normal", delete t.arg, e.completion = t
			}

			function I(e) {
				this.tryEntries = [{
					tryLoc: "root"
				}], e.forEach(k, this), this.reset(!0)
			}

			function O(e) {
				if (e) {
					var t = e[a];
					if (t) return t.call(e);
					if ("function" == typeof e.next) return e;
					if (!isNaN(e.length)) {
						var n = -1,
							o = function t() {
								for (; ++n < e.length;)
									if (i.call(e, n)) return t.value = e[n], t.done = !1, t;
								return t.value = r, t.done = !0, t
							};
						return o.next = o
					}
				}
				return {
					next: P
				}
			}

			function P() {
				return {
					value: r,
					done: !0
				}
			}
		}(function() {
			return this
		}() || Function("return this")())
	});
	const ajxa = {
		request: (e, t = "GET", r = {}) => (e || console.warn("!!request url can not be empty"), new Promise((n, i) => {
			wx.request({
				url: e,
				method: t,
				data: r,
				success(e) {
					n(e.data)
				},
				fail(e) {
					i(e)
				}
			})
		}))
	};
	var miniapp = createCommonjsModule(function(module) {
		var Module;
		Module || (Module = (void 0 !== Module ? Module : null) || {});
		var moduleOverrides = {};
		for (var key in Module) Module.hasOwnProperty(key) && (moduleOverrides[key] = Module[key]);
		var ENVIRONMENT_IS_WEB = !1,
			ENVIRONMENT_IS_WORKER = !1,
			ENVIRONMENT_IS_NODE = !1,
			ENVIRONMENT_IS_SHELL = !1,
			nodeFS, nodePath;
		if (Module.ENVIRONMENT)
			if ("WEB" === Module.ENVIRONMENT) ENVIRONMENT_IS_WEB = !0;
			else if ("WORKER" === Module.ENVIRONMENT) ENVIRONMENT_IS_WORKER = !0;
		else if ("NODE" === Module.ENVIRONMENT) ENVIRONMENT_IS_NODE = !0;
		else {
			if ("SHELL" !== Module.ENVIRONMENT) throw new Error(
				"The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.");
			ENVIRONMENT_IS_SHELL = !0
		} else ENVIRONMENT_IS_WEB = "object" == typeof window, ENVIRONMENT_IS_WORKER = "function" == typeof importScripts,
			ENVIRONMENT_IS_NODE = "object" == typeof process_on && "function" == typeof commonjsRequire && !ENVIRONMENT_IS_WEB &&
			!ENVIRONMENT_IS_WORKER, ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !
			ENVIRONMENT_IS_WORKER;
		if (ENVIRONMENT_IS_SHELL = !1, ENVIRONMENT_IS_NODE) Module.print || (Module.print = console.log), Module.printErr ||
			(Module.printErr = console.warn), Module.read = function(e, t) {
				e = nodePath.normalize(e);
				var r = nodeFS.readFileSync(e);
				return t ? r : r.toString()
			}, Module.readBinary = function(e) {
				var t = Module.read(e, !0);
				return t.buffer || (t = new Uint8Array(t)), assert(t.buffer), t
			}, Module.load = function(e) {
				globalEval(read(e))
			}, Module.thisProgram || (process_on.argv.length > 1 ? Module.thisProgram = process_on.argv[1].replace(/\\/g, "/") :
				Module.thisProgram = "unknown-program"), Module.arguments = process_on.argv.slice(2), module.exports = Module,
			process_on.on("uncaughtException", function(e) {
				if (!(e instanceof ExitStatus)) throw e
			}), Module.inspect = function() {
				return "[Emscripten Module object]"
			};
		else if (ENVIRONMENT_IS_SHELL) Module.print || (Module.print = print), "undefined" != typeof printErr && (Module.printErr =
			printErr), "undefined" != typeof read ? Module.read = read : Module.read = function() {
			throw "no read() available"
		}, Module.readBinary = function(e) {
			if ("function" == typeof readbuffer) return new Uint8Array(readbuffer(e));
			var t = read(e, "binary");
			return assert("object" == typeof t), t
		}, "undefined" != typeof scriptArgs ? Module.arguments = scriptArgs : void 0 !== arguments && (Module.arguments =
			arguments), "function" == typeof quit && (Module.quit = function(e, t) {
			quit(e)
		});
		else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
			if (Module.read = function(e) {
					var t = new XMLHttpRequest;
					return t.open("GET", e, !1), t.send(null), t.responseText
				}, ENVIRONMENT_IS_WORKER && (Module.readBinary = function(e) {
					var t = new XMLHttpRequest;
					return t.open("GET", e, !1), t.responseType = "arraybuffer", t.send(null), new Uint8Array(t.response)
				}), Module.readAsync = function(e, t, r) {
					var n = new XMLHttpRequest;
					n.open("GET", e, !0), n.responseType = "arraybuffer", n.onload = function() {
						200 == n.status || 0 == n.status && n.response ? t(n.response) : r()
					}, n.onerror = r, n.send(null)
				}, void 0 !== arguments && (Module.arguments = arguments), "undefined" != typeof console) Module.print || (
				Module.print = function(e) {
					console.log(e)
				}), Module.printErr || (Module.printErr = function(e) {
				console.warn(e)
			});
			else {
				var TRY_USE_DUMP = !1;
				Module.print || (Module.print = TRY_USE_DUMP && "undefined" != typeof dump ? function(e) {
					dump(e)
				} : function(e) {})
			}
			ENVIRONMENT_IS_WORKER && (Module.load = importScripts), void 0 === Module.setWindowTitle && (Module.setWindowTitle =
				function(e) {
					document.title = e
				})
		}

		function globalEval(e) {
			eval.call(null, e)
		}
		for (var key in !Module.load && Module.read && (Module.load = function(e) {
					globalEval(Module.read(e))
				}), Module.print || (Module.print = function() {}), Module.printErr || (Module.printErr = Module.print), Module.arguments ||
				(Module.arguments = []), Module.thisProgram || (Module.thisProgram = "./this.program"), Module.quit || (Module.quit =
					function(e, t) {
						throw t
					}), Module.print = Module.print, Module.printErr = Module.printErr, Module.preRun = [], Module.postRun = [],
				moduleOverrides) moduleOverrides.hasOwnProperty(key) && (Module[key] = moduleOverrides[key]);
		moduleOverrides = void 0;
		var Runtime = {
			setTempRet0: function(e) {
				return tempRet0 = e, e
			},
			getTempRet0: function() {
				return tempRet0
			},
			stackSave: function() {
				return STACKTOP
			},
			stackRestore: function(e) {
				STACKTOP = e
			},
			getNativeTypeSize: function(e) {
				switch (e) {
					case "i1":
					case "i8":
						return 1;
					case "i16":
						return 2;
					case "i32":
						return 4;
					case "i64":
						return 8;
					case "float":
						return 4;
					case "double":
						return 8;
					default:
						if ("*" === e[e.length - 1]) return Runtime.QUANTUM_SIZE;
						if ("i" === e[0]) {
							var t = parseInt(e.substr(1));
							return assert(t % 8 == 0), t / 8
						}
						return 0
				}
			},
			getNativeFieldSize: function(e) {
				return Math.max(Runtime.getNativeTypeSize(e), Runtime.QUANTUM_SIZE)
			},
			STACK_ALIGN: 16,
			prepVararg: function(e, t) {
				return "double" === t || "i64" === t ? 7 & e && (assert(4 == (7 & e)), e += 4) : assert(0 == (3 & e)), e
			},
			getAlignSize: function(e, t, r) {
				return r || "i64" != e && "double" != e ? e ? Math.min(t || (e ? Runtime.getNativeFieldSize(e) : 0), Runtime.QUANTUM_SIZE) :
					Math.min(t, 8) : 8
			},
			dynCall: function(e, t, r) {
				return r && r.length ? (assert(r.length == e.length - 1), assert("dynCall_" + e in Module,
					"bad function pointer type - no table for sig '" + e + "'"), Module["dynCall_" + e].apply(null, [t].concat(
					r))) : (assert(1 == e.length), assert("dynCall_" + e in Module,
					"bad function pointer type - no table for sig '" + e + "'"), Module["dynCall_" + e].call(null, t))
			},
			functionPointers: [],
			addFunction: function(e) {
				for (var t = 0; t < Runtime.functionPointers.length; t++)
					if (!Runtime.functionPointers[t]) return Runtime.functionPointers[t] = e, 2 * (1 + t);
				throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
			},
			removeFunction: function(e) {
				Runtime.functionPointers[(e - 2) / 2] = null
			},
			warnOnce: function(e) {
				Runtime.warnOnce.shown || (Runtime.warnOnce.shown = {}), Runtime.warnOnce.shown[e] || (Runtime.warnOnce.shown[
					e] = 1, Module.printErr(e))
			},
			funcWrappers: {},
			getFuncWrapper: function(e, t) {
				if (e) {
					assert(t), Runtime.funcWrappers[t] || (Runtime.funcWrappers[t] = {});
					var r = Runtime.funcWrappers[t];
					return r[e] || (1 === t.length ? r[e] = function() {
						return Runtime.dynCall(t, e)
					} : 2 === t.length ? r[e] = function(r) {
						return Runtime.dynCall(t, e, [r])
					} : r[e] = function() {
						return Runtime.dynCall(t, e, Array.prototype.slice.call(arguments))
					}), r[e]
				}
			},
			getCompilerSetting: function(e) {
				throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
			},
			stackAlloc: function(e) {
				var t = STACKTOP;
				return assert((0 | (STACKTOP = (STACKTOP = STACKTOP + e | 0) + 15 & -16)) < (0 | STACK_MAX) | 0), t
			},
			staticAlloc: function(e) {
				var t = STATICTOP;
				return STATICTOP = (STATICTOP = STATICTOP + (assert(!staticSealed), e) | 0) + 15 & -16, t
			},
			dynamicAlloc: function(e) {
				assert(DYNAMICTOP_PTR);
				var t = HEAP32[DYNAMICTOP_PTR >> 2],
					r = -16 & (t + e + 15 | 0);
				if ((HEAP32[DYNAMICTOP_PTR >> 2] = r, r >= TOTAL_MEMORY) && !enlargeMemory()) return HEAP32[DYNAMICTOP_PTR >>
					2] = t, 0;
				return t
			},
			alignMemory: function(e, t) {
				return e = Math.ceil(e / (t || 16)) * (t || 16)
			},
			makeBigInt: function(e, t, r) {
				return r ? +(e >>> 0) + 4294967296 * +(t >>> 0) : +(e >>> 0) + 4294967296 * +(0 | t)
			},
			GLOBAL_BASE: 8,
			QUANTUM_SIZE: 4,
			__dummy__: 0
		};
		Module.Runtime = Runtime;
		var ABORT = 0,
			cwrap, ccall;

		function assert(e, t) {
			e || abort("Assertion failed: " + t)
		}

		function getCFunc(ident) {
			var func = Module["_" + ident];
			if (!func) try {
				func = eval("_" + ident)
			} catch (e) {}
			return assert(func, "Cannot call unknown function " + ident +
				" (perhaps LLVM optimizations or closure removed it?)"), func
		}

		function setValue(e, t, r, n) {
			switch ("*" === (r = r || "i8").charAt(r.length - 1) && (r = "i32"), r) {
				case "i1":
				case "i8":
					HEAP8[e >> 0] = t;
					break;
				case "i16":
					HEAP16[e >> 1] = t;
					break;
				case "i32":
					HEAP32[e >> 2] = t;
					break;
				case "i64":
					tempI64 = [t >>> 0, (tempDouble = t, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (0 | Math_min(+Math_floor(
						tempDouble / 4294967296), 4294967295)) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) /
						4294967296) >>> 0 : 0)], HEAP32[e >> 2] = tempI64[0], HEAP32[e + 4 >> 2] = tempI64[1];
					break;
				case "float":
					HEAPF32[e >> 2] = t;
					break;
				case "double":
					HEAPF64[e >> 3] = t;
					break;
				default:
					abort("invalid type for setValue: " + r)
			}
		}

		function getValue(e, t, r) {
			switch ("*" === (t = t || "i8").charAt(t.length - 1) && (t = "i32"), t) {
				case "i1":
				case "i8":
					return HEAP8[e >> 0];
				case "i16":
					return HEAP16[e >> 1];
				case "i32":
				case "i64":
					return HEAP32[e >> 2];
				case "float":
					return HEAPF32[e >> 2];
				case "double":
					return HEAPF64[e >> 3];
				default:
					abort("invalid type for setValue: " + t)
			}
			return null
		}! function() {
			var JSfuncs = {
					stackSave: function() {
						Runtime.stackSave()
					},
					stackRestore: function() {
						Runtime.stackRestore()
					},
					arrayToC: function(e) {
						var t = Runtime.stackAlloc(e.length);
						return writeArrayToMemory(e, t), t
					},
					stringToC: function(e) {
						var t = 0;
						if (null != e && 0 !== e) {
							var r = 1 + (e.length << 2);
							stringToUTF8(e, t = Runtime.stackAlloc(r), r)
						}
						return t
					}
				},
				toC = {
					string: JSfuncs.stringToC,
					array: JSfuncs.arrayToC
				};
			ccall = function(e, t, r, n, i) {
				var o = getCFunc(e),
					a = [],
					u = 0;
				if (assert("array" !== t, 'Return type should not be "array".'), n)
					for (var s = 0; s < n.length; s++) {
						var f = toC[r[s]];
						f ? (0 === u && (u = Runtime.stackSave()), a[s] = f(n[s])) : a[s] = n[s]
					}
				var l = o.apply(null, a);
				if (i && i.async || "object" != typeof EmterpreterAsync || assert(!EmterpreterAsync.state,
						"cannot start async op with normal JS calling ccall"), i && i.async && assert(!t,
						"async ccalls cannot return values"), "string" === t && (l = Pointer_stringify(l)), 0 !== u) {
					if (i && i.async) return void EmterpreterAsync.asyncFinalizers.push(function() {
						Runtime.stackRestore(u)
					});
					Runtime.stackRestore(u)
				}
				return l
			};
			var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;

			function parseJSFunc(e) {
				var t = e.toString().match(sourceRegex).slice(1);
				return {
					arguments: t[0],
					body: t[1],
					returnValue: t[2]
				}
			}
			var JSsource = null;

			function ensureJSsource() {
				if (!JSsource)
					for (var e in JSsource = {}, JSfuncs) JSfuncs.hasOwnProperty(e) && (JSsource[e] = parseJSFunc(JSfuncs[e]))
			}
			cwrap = function cwrap(ident, returnType, argTypes) {
				argTypes = argTypes || [];
				var cfunc = getCFunc(ident),
					numericArgs = argTypes.every(function(e) {
						return "number" === e
					}),
					numericRet = "string" !== returnType;
				if (numericRet && numericArgs) return cfunc;
				var argNames = argTypes.map(function(e, t) {
						return "$" + t
					}),
					funcstr = "(function(" + argNames.join(",") + ") {",
					nargs = argTypes.length;
				if (!numericArgs) {
					ensureJSsource(), funcstr += "var stack = " + JSsource.stackSave.body + ";";
					for (var i = 0; i < nargs; i++) {
						var arg = argNames[i],
							type = argTypes[i];
						if ("number" !== type) {
							var convertCode = JSsource[type + "ToC"];
							funcstr += "var " + convertCode.arguments + " = " + arg + ";", funcstr += convertCode.body + ";", funcstr +=
								arg + "=(" + convertCode.returnValue + ");"
						}
					}
				}
				var cfuncname = parseJSFunc(function() {
					return cfunc
				}).returnValue;
				if (funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");", !numericRet) {
					var strgfy = parseJSFunc(function() {
						return Pointer_stringify
					}).returnValue;
					funcstr += "ret = " + strgfy + "(ret);"
				}
				return funcstr +=
					"if (typeof EmterpreterAsync === 'object') { assert(!EmterpreterAsync.state, 'cannot start async op with normal JS calling cwrap') }",
					numericArgs || (ensureJSsource(), funcstr += JSsource.stackRestore.body.replace("()", "(stack)") + ";"),
					funcstr += "return ret})", eval(funcstr)
			}
		}(), Module.ccall = ccall, Module.cwrap = cwrap, Module.setValue = setValue, Module.getValue = getValue;
		var ALLOC_NORMAL = 0,
			ALLOC_STACK = 1,
			ALLOC_STATIC = 2,
			ALLOC_DYNAMIC = 3,
			ALLOC_NONE = 4;

		function allocate(e, t, r, n) {
			var i, o;
			"number" == typeof e ? (i = !0, o = e) : (i = !1, o = e.length);
			var a, u = "string" == typeof t ? t : null;
			if (a = r == ALLOC_NONE ? n : ["function" == typeof _malloc ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc,
					Runtime.staticAlloc, Runtime.dynamicAlloc
				][void 0 === r ? ALLOC_STATIC : r](Math.max(o, u ? 1 : t.length)), i) {
				var s;
				n = a;
				for (assert(0 == (3 & a)), s = a + (-4 & o); n < s; n += 4) HEAP32[n >> 2] = 0;
				for (s = a + o; n < s;) HEAP8[n++ >> 0] = 0;
				return a
			}
			if ("i8" === u) return e.subarray || e.slice ? HEAPU8.set(e, a) : HEAPU8.set(new Uint8Array(e), a), a;
			for (var f, l, c, d = 0; d < o;) {
				var h = e[d];
				"function" == typeof h && (h = Runtime.getFunctionIndex(h)), 0 !== (f = u || t[d]) ? (assert(f,
					"Must know what type to store in allocate!"), "i64" == f && (f = "i32"), setValue(a + d, h, f), c !== f && (l =
					Runtime.getNativeTypeSize(f), c = f), d += l) : d++
			}
			return a
		}

		function getMemory(e) {
			return staticSealed ? runtimeInitialized ? _malloc(e) : Runtime.dynamicAlloc(e) : Runtime.staticAlloc(e)
		}

		function Pointer_stringify(e, t) {
			if (0 === t || !e) return "";
			for (var r, n = 0, i = 0; assert(e + i < TOTAL_MEMORY), n |= r = HEAPU8[e + i >> 0], (0 != r || t) && (i++, !t ||
					i != t););
			t || (t = i);
			var o = "";
			if (n < 128) {
				for (var a, u = 1024; t > 0;) a = String.fromCharCode.apply(String, HEAPU8.subarray(e, e + Math.min(t, u))), o =
					o ? o + a : a, e += u, t -= u;
				return o
			}
			return Module.UTF8ToString(e)
		}

		function AsciiToString(e) {
			for (var t = "";;) {
				var r = HEAP8[e++ >> 0];
				if (!r) return t;
				t += String.fromCharCode(r)
			}
		}

		function stringToAscii(e, t) {
			return writeAsciiToMemory(e, t, !1)
		}
		Module.ALLOC_NORMAL = ALLOC_NORMAL, Module.ALLOC_STACK = ALLOC_STACK, Module.ALLOC_STATIC = ALLOC_STATIC, Module.ALLOC_DYNAMIC =
			ALLOC_DYNAMIC, Module.ALLOC_NONE = ALLOC_NONE, Module.allocate = allocate, Module.getMemory = getMemory, Module.Pointer_stringify =
			Pointer_stringify, Module.AsciiToString = AsciiToString, Module.stringToAscii = stringToAscii;
		var UTF8Decoder = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0;

		function UTF8ArrayToString(e, t) {
			for (var r = t; e[r];) ++r;
			if (r - t > 16 && e.subarray && UTF8Decoder) return UTF8Decoder.decode(e.subarray(t, r));
			for (var n, i, o, a, u, s = "";;) {
				if (!(n = e[t++])) return s;
				if (128 & n)
					if (i = 63 & e[t++], 192 != (224 & n))
						if (o = 63 & e[t++], 224 == (240 & n) ? n = (15 & n) << 12 | i << 6 | o : (a = 63 & e[t++], 240 == (248 & n) ?
								n = (7 & n) << 18 | i << 12 | o << 6 | a : (u = 63 & e[t++], n = 248 == (252 & n) ? (3 & n) << 24 | i << 18 |
									o << 12 | a << 6 | u : (1 & n) << 30 | i << 24 | o << 18 | a << 12 | u << 6 | 63 & e[t++])), n < 65536) s +=
							String.fromCharCode(n);
						else {
							var f = n - 65536;
							s += String.fromCharCode(55296 | f >> 10, 56320 | 1023 & f)
						}
				else s += String.fromCharCode((31 & n) << 6 | i);
				else s += String.fromCharCode(n)
			}
		}

		function UTF8ToString(e) {
			return UTF8ArrayToString(HEAPU8, e)
		}

		function stringToUTF8Array(e, t, r, n) {
			if (!(n > 0)) return 0;
			for (var i = r, o = r + n - 1, a = 0; a < e.length; ++a) {
				var u = e.charCodeAt(a);
				if (u >= 55296 && u <= 57343 && (u = 65536 + ((1023 & u) << 10) | 1023 & e.charCodeAt(++a)), u <= 127) {
					if (r >= o) break;
					t[r++] = u
				} else if (u <= 2047) {
					if (r + 1 >= o) break;
					t[r++] = 192 | u >> 6, t[r++] = 128 | 63 & u
				} else if (u <= 65535) {
					if (r + 2 >= o) break;
					t[r++] = 224 | u >> 12, t[r++] = 128 | u >> 6 & 63, t[r++] = 128 | 63 & u
				} else if (u <= 2097151) {
					if (r + 3 >= o) break;
					t[r++] = 240 | u >> 18, t[r++] = 128 | u >> 12 & 63, t[r++] = 128 | u >> 6 & 63, t[r++] = 128 | 63 & u
				} else if (u <= 67108863) {
					if (r + 4 >= o) break;
					t[r++] = 248 | u >> 24, t[r++] = 128 | u >> 18 & 63, t[r++] = 128 | u >> 12 & 63, t[r++] = 128 | u >> 6 & 63, t[
						r++] = 128 | 63 & u
				} else {
					if (r + 5 >= o) break;
					t[r++] = 252 | u >> 30, t[r++] = 128 | u >> 24 & 63, t[r++] = 128 | u >> 18 & 63, t[r++] = 128 | u >> 12 & 63,
						t[r++] = 128 | u >> 6 & 63, t[r++] = 128 | 63 & u
				}
			}
			return t[r] = 0, r - i
		}

		function stringToUTF8(e, t, r) {
			return assert("number" == typeof r,
				"stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"
			), stringToUTF8Array(e, HEAPU8, t, r)
		}

		function lengthBytesUTF8(e) {
			for (var t = 0, r = 0; r < e.length; ++r) {
				var n = e.charCodeAt(r);
				n >= 55296 && n <= 57343 && (n = 65536 + ((1023 & n) << 10) | 1023 & e.charCodeAt(++r)), n <= 127 ? ++t : t += n <=
					2047 ? 2 : n <= 65535 ? 3 : n <= 2097151 ? 4 : n <= 67108863 ? 5 : 6
			}
			return t
		}
		Module.UTF8ArrayToString = UTF8ArrayToString, Module.UTF8ToString = UTF8ToString, Module.stringToUTF8Array =
			stringToUTF8Array, Module.stringToUTF8 = stringToUTF8, Module.lengthBytesUTF8 = lengthBytesUTF8;
		var UTF16Decoder = "undefined" != typeof TextDecoder ? new TextDecoder("utf-16le") : void 0,
			HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64, STATIC_BASE, STATICTOP,
			staticSealed, STACK_BASE, STACKTOP, STACK_MAX, DYNAMIC_BASE, DYNAMICTOP_PTR;

		function demangle(e) {
			var t = Module.___cxa_demangle || Module.__cxa_demangle;
			if (t) {
				try {
					var r = e.substr(1),
						n = lengthBytesUTF8(r) + 1,
						i = _malloc(n);
					stringToUTF8(r, i, n);
					var o = _malloc(4),
						a = t(i, 0, 0, o);
					if (0 === getValue(o, "i32") && a) return Pointer_stringify(a)
				} catch (e) {} finally {
					i && _free(i), o && _free(o), a && _free(a)
				}
				return e
			}
			return Runtime.warnOnce("warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling"), e
		}

		function demangleAll(e) {
			return e.replace(/__Z[\w\d_]+/g, function(e) {
				var t = demangle(e);
				return e === t ? e : e + " [" + t + "]"
			})
		}

		function jsStackTrace() {
			var e = new Error;
			if (!e.stack) {
				try {
					throw new Error(0)
				} catch (t) {
					e = t
				}
				if (!e.stack) return "(no stack trace available)"
			}
			return e.stack.toString()
		}

		function stackTrace() {
			var e = jsStackTrace();
			return Module.extraStackTrace && (e += "\n" + Module.extraStackTrace()), demangleAll(e)
		}

		function updateGlobalBufferViews() {
			Module.HEAP8 = HEAP8 = new Int8Array(buffer), Module.HEAP16 = HEAP16 = new Int16Array(buffer), Module.HEAP32 =
				HEAP32 = new Int32Array(buffer), Module.HEAPU8 = HEAPU8 = new Uint8Array(buffer), Module.HEAPU16 = HEAPU16 = new Uint16Array(
					buffer), Module.HEAPU32 = HEAPU32 = new Uint32Array(buffer), Module.HEAPF32 = HEAPF32 = new Float32Array(buffer),
				Module.HEAPF64 = HEAPF64 = new Float64Array(buffer)
		}

		function writeStackCookie() {
			assert(0 == (3 & STACK_MAX)), HEAPU32[(STACK_MAX >> 2) - 1] = 34821223, HEAPU32[(STACK_MAX >> 2) - 2] =
				2310721022
		}

		function checkStackCookie() {
			if (34821223 == HEAPU32[(STACK_MAX >> 2) - 1] && 2310721022 == HEAPU32[(STACK_MAX >> 2) - 2] || abort(
					"Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x" +
					HEAPU32[(STACK_MAX >> 2) - 2].toString(16) + " " + HEAPU32[(STACK_MAX >> 2) - 1].toString(16)), 1668509029 !==
				HEAP32[0]) throw "Runtime error: The application has corrupted its heap memory area (address zero)!"
		}

		function abortStackOverflow(e) {
			abort("Stack overflow! Attempted to allocate " + e + " bytes on the stack, but stack has only " + (STACK_MAX -
				Module.asm.stackSave() + e) + " bytes available!")
		}

		function abortOnCannotGrowMemory() {
			abort(
				"Cannot enlarge memory arrays. Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value " +
				TOTAL_MEMORY +
				", (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or (4) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 "
			)
		}

		function enlargeMemory() {
			abortOnCannotGrowMemory()
		}
		Module.stackTrace = stackTrace, STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE =
			DYNAMICTOP_PTR = 0, staticSealed = !1;
		var TOTAL_STACK = Module.TOTAL_STACK || 5242880,
			TOTAL_MEMORY = Module.TOTAL_MEMORY || 16777216;

		function getTotalMemory() {
			return TOTAL_MEMORY
		}
		if (TOTAL_MEMORY < TOTAL_STACK && Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " +
				TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")"), assert("undefined" != typeof Int32Array && "undefined" !=
				typeof Float64Array && void 0 !== Int32Array.prototype.subarray && void 0 !== Int32Array.prototype.set,
				"JS engine does not provide full typed array support"), Module.buffer ? (buffer = Module.buffer, assert(buffer.byteLength ===
				TOTAL_MEMORY, "provided buffer should be " + TOTAL_MEMORY + " bytes, but it is " + buffer.byteLength)) : (buffer =
				new ArrayBuffer(TOTAL_MEMORY), assert(buffer.byteLength === TOTAL_MEMORY)), updateGlobalBufferViews(), HEAP32[0] =
			1668509029, HEAP16[1] = 25459, 115 !== HEAPU8[2] || 99 !== HEAPU8[3]) throw "Runtime error: expected the system to be little-endian!";

		function callRuntimeCallbacks(e) {
			for (; e.length > 0;) {
				var t = e.shift();
				if ("function" != typeof t) {
					var r = t.func;
					"number" == typeof r ? void 0 === t.arg ? Module.dynCall_v(r) : Module.dynCall_vi(r, t.arg) : r(void 0 === t.arg ?
						null : t.arg)
				} else t()
			}
		}
		Module.HEAP = HEAP, Module.buffer = buffer, Module.HEAP8 = HEAP8, Module.HEAP16 = HEAP16, Module.HEAP32 = HEAP32,
			Module.HEAPU8 = HEAPU8, Module.HEAPU16 = HEAPU16, Module.HEAPU32 = HEAPU32, Module.HEAPF32 = HEAPF32, Module.HEAPF64 =
			HEAPF64;
		var __ATPRERUN__ = [],
			__ATINIT__ = [],
			__ATMAIN__ = [],
			__ATEXIT__ = [],
			__ATPOSTRUN__ = [],
			runtimeInitialized = !1,
			runtimeExited = !1;

		function preRun() {
			if (Module.preRun)
				for ("function" == typeof Module.preRun && (Module.preRun = [Module.preRun]); Module.preRun.length;) addOnPreRun(
					Module.preRun.shift());
			callRuntimeCallbacks(__ATPRERUN__)
		}

		function ensureInitRuntime() {
			checkStackCookie(), runtimeInitialized || (runtimeInitialized = !0, callRuntimeCallbacks(__ATINIT__))
		}

		function preMain() {
			checkStackCookie(), callRuntimeCallbacks(__ATMAIN__)
		}

		function exitRuntime() {
			checkStackCookie(), callRuntimeCallbacks(__ATEXIT__), runtimeExited = !0
		}

		function postRun() {
			if (checkStackCookie(), Module.postRun)
				for ("function" == typeof Module.postRun && (Module.postRun = [Module.postRun]); Module.postRun.length;)
					addOnPostRun(Module.postRun.shift());
			callRuntimeCallbacks(__ATPOSTRUN__)
		}

		function addOnPreRun(e) {
			__ATPRERUN__.unshift(e)
		}

		function addOnInit(e) {
			__ATINIT__.unshift(e)
		}

		function addOnPreMain(e) {
			__ATMAIN__.unshift(e)
		}

		function addOnExit(e) {
			__ATEXIT__.unshift(e)
		}

		function addOnPostRun(e) {
			__ATPOSTRUN__.unshift(e)
		}

		function intArrayFromString(e, t, r) {
			var n = r > 0 ? r : lengthBytesUTF8(e) + 1,
				i = new Array(n),
				o = stringToUTF8Array(e, i, 0, i.length);
			return t && (i.length = o), i
		}

		function intArrayToString(e) {
			for (var t = [], r = 0; r < e.length; r++) {
				var n = e[r];
				n > 255 && (assert(!1, "Character code " + n + " (" + String.fromCharCode(n) + ")  at offset " + r +
					" not in 0x00-0xFF."), n &= 255), t.push(String.fromCharCode(n))
			}
			return t.join("")
		}

		function writeStringToMemory(e, t, r) {
			var n, i;
			Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!"), r &&
				(i = t + lengthBytesUTF8(e), n = HEAP8[i]), stringToUTF8(e, t, 1 / 0), r && (HEAP8[i] = n)
		}

		function writeArrayToMemory(e, t) {
			assert(e.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)"), HEAP8.set(
				e, t)
		}

		function writeAsciiToMemory(e, t, r) {
			for (var n = 0; n < e.length; ++n) assert(e.charCodeAt(n) == e.charCodeAt(n) & 255), HEAP8[t++ >> 0] = e.charCodeAt(
				n);
			r || (HEAP8[t >> 0] = 0)
		}
		Module.addOnPreRun = addOnPreRun, Module.addOnInit = addOnInit, Module.addOnPreMain = addOnPreMain, Module.addOnExit =
			addOnExit, Module.addOnPostRun = addOnPostRun, Module.intArrayFromString = intArrayFromString, Module.intArrayToString =
			intArrayToString, Module.writeStringToMemory = writeStringToMemory, Module.writeArrayToMemory =
			writeArrayToMemory, Module.writeAsciiToMemory = writeAsciiToMemory, Math.imul && -5 === Math.imul(4294967295, 5) ||
			(Math.imul = function(e, t) {
				var r = 65535 & e,
					n = 65535 & t;
				return r * n + ((e >>> 16) * n + r * (t >>> 16) << 16) | 0
			}), Math.imul = Math.imul, Math.clz32 || (Math.clz32 = function(e) {
				e >>>= 0;
				for (var t = 0; t < 32; t++)
					if (e & 1 << 31 - t) return t;
				return 32
			}), Math.clz32 = Math.clz32, Math.trunc || (Math.trunc = function(e) {
				return e < 0 ? Math.ceil(e) : Math.floor(e)
			}), Math.trunc = Math.trunc;
		var Math_abs = Math.abs,
			Math_ceil = Math.ceil,
			Math_floor = Math.floor,
			Math_min = Math.min,
			runDependencies = 0,
			runDependencyWatcher = null,
			dependenciesFulfilled = null,
			runDependencyTracking = {};

		function addRunDependency(e) {
			runDependencies++, Module.monitorRunDependencies && Module.monitorRunDependencies(runDependencies), e ? (assert(!
					runDependencyTracking[e]), runDependencyTracking[e] = 1, null === runDependencyWatcher && "undefined" !=
				typeof setInterval && (runDependencyWatcher = setInterval(function() {
					if (ABORT) return clearInterval(runDependencyWatcher), void(runDependencyWatcher = null);
					var e = !1;
					for (var t in runDependencyTracking) e || (e = !0, Module.printErr("still waiting on run dependencies:")),
						Module.printErr("dependency: " + t);
					e && Module.printErr("(end of list)")
				}, 1e4))) : Module.printErr("warning: run dependency added without ID")
		}

		function removeRunDependency(e) {
			if (runDependencies--, Module.monitorRunDependencies && Module.monitorRunDependencies(runDependencies), e ? (
					assert(runDependencyTracking[e]), delete runDependencyTracking[e]) : Module.printErr(
					"warning: run dependency removed without ID"), 0 == runDependencies && (null !== runDependencyWatcher && (
					clearInterval(runDependencyWatcher), runDependencyWatcher = null), dependenciesFulfilled)) {
				var t = dependenciesFulfilled;
				dependenciesFulfilled = null, t()
			}
		}
		Module.addRunDependency = addRunDependency, Module.removeRunDependency = removeRunDependency, Module.preloadedImages = {},
			Module.preloadedAudios = {};
		var FS = {
			error: function() {
				abort(
					"Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with  -s FORCE_FILESYSTEM=1"
				)
			},
			init: function() {
				FS.error()
			},
			createDataFile: function() {
				FS.error()
			},
			createPreloadedFile: function() {
				FS.error()
			},
			createLazyFile: function() {
				FS.error()
			},
			open: function() {
				FS.error()
			},
			mkdev: function() {
				FS.error()
			},
			registerDevice: function() {
				FS.error()
			},
			analyzePath: function() {
				FS.error()
			},
			loadFilesFromDB: function() {
				FS.error()
			},
			ErrnoError: function() {
				FS.error()
			}
		};
		Module.FS_createDataFile = FS.createDataFile, Module.FS_createPreloadedFile = FS.createPreloadedFile, STATIC_BASE =
			Runtime.GLOBAL_BASE, STATICTOP = STATIC_BASE + 5872, __ATINIT__.push(), allocate([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 18, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 233, 18, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255,
				255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 141, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94,
				188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, 57, 114, 228, 211, 189, 97, 194, 159, 37, 74,
				148, 51, 102, 204, 131, 29, 58, 116, 232, 203, 141, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154,
				47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, 57, 114, 228, 211, 189, 97, 194, 159, 37,
				74, 148, 51, 102, 204, 131, 29, 58, 116, 232, 203, 141, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77,
				154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, 57, 114, 228, 211, 189, 97, 194,
				159, 37, 74, 148, 51, 102, 204, 131, 29, 58, 116, 232, 203, 141, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216,
				171, 77, 154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, 57, 114, 228, 211, 189, 97,
				194, 159, 37, 74, 148, 51, 102, 204, 131, 29, 58, 116, 232, 203, 141, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108,
				216, 171, 77, 154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, 57, 114, 228, 211,
				189, 97, 194, 159, 37, 74, 148, 51, 102, 204, 131, 29, 58, 116, 232, 203, 99, 124, 119, 123, 242, 107, 111, 197,
				48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114,
				192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154,
				7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83,
				209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249,
				2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12,
				19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184,
				20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109,
				141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31,
				75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17,
				105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15,
				176, 84, 187, 22, 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130,
				155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11,
				66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100,
				134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87,
				167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143,
				202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240,
				180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29,
				41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120,
				205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181,
				74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83,
				153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57,
				58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
				21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
				44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 107, 51, 52,
				98, 98, 103, 98, 107, 106, 34, 49, 102, 52, 107, 101, 37, 48, 50, 88, 0, 96, 55, 51, 52, 98, 99, 103, 98, 107,
				106, 54, 49, 101, 52, 97, 101, 49, 107, 48, 54, 54, 97, 106, 48, 100, 98, 49, 52, 49, 96, 49, 101, 84, 33, 34,
				25, 13, 1, 2, 3, 17, 75, 28, 12, 16, 4, 11, 29, 18, 30, 39, 104, 110, 111, 112, 113, 98, 32, 5, 6, 15, 19, 20,
				21, 26, 8, 22, 7, 40, 36, 23, 24, 9, 10, 14, 27, 31, 37, 35, 131, 130, 125, 38, 42, 43, 60, 61, 62, 63, 67, 71,
				74, 77, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, 105, 106, 107, 108, 114, 115, 116, 121,
				122, 123, 124, 0, 73, 108, 108, 101, 103, 97, 108, 32, 98, 121, 116, 101, 32, 115, 101, 113, 117, 101, 110, 99,
				101, 0, 68, 111, 109, 97, 105, 110, 32, 101, 114, 114, 111, 114, 0, 82, 101, 115, 117, 108, 116, 32, 110, 111,
				116, 32, 114, 101, 112, 114, 101, 115, 101, 110, 116, 97, 98, 108, 101, 0, 78, 111, 116, 32, 97, 32, 116, 116,
				121, 0, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 32, 100, 101, 110, 105, 101, 100, 0, 79, 112, 101, 114,
				97, 116, 105, 111, 110, 32, 110, 111, 116, 32, 112, 101, 114, 109, 105, 116, 116, 101, 100, 0, 78, 111, 32, 115,
				117, 99, 104, 32, 102, 105, 108, 101, 32, 111, 114, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 0, 78, 111,
				32, 115, 117, 99, 104, 32, 112, 114, 111, 99, 101, 115, 115, 0, 70, 105, 108, 101, 32, 101, 120, 105, 115, 116,
				115, 0, 86, 97, 108, 117, 101, 32, 116, 111, 111, 32, 108, 97, 114, 103, 101, 32, 102, 111, 114, 32, 100, 97,
				116, 97, 32, 116, 121, 112, 101, 0, 78, 111, 32, 115, 112, 97, 99, 101, 32, 108, 101, 102, 116, 32, 111, 110,
				32, 100, 101, 118, 105, 99, 101, 0, 79, 117, 116, 32, 111, 102, 32, 109, 101, 109, 111, 114, 121, 0, 82, 101,
				115, 111, 117, 114, 99, 101, 32, 98, 117, 115, 121, 0, 73, 110, 116, 101, 114, 114, 117, 112, 116, 101, 100, 32,
				115, 121, 115, 116, 101, 109, 32, 99, 97, 108, 108, 0, 82, 101, 115, 111, 117, 114, 99, 101, 32, 116, 101, 109,
				112, 111, 114, 97, 114, 105, 108, 121, 32, 117, 110, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 73, 110, 118,
				97, 108, 105, 100, 32, 115, 101, 101, 107, 0, 67, 114, 111, 115, 115, 45, 100, 101, 118, 105, 99, 101, 32, 108,
				105, 110, 107, 0, 82, 101, 97, 100, 45, 111, 110, 108, 121, 32, 102, 105, 108, 101, 32, 115, 121, 115, 116, 101,
				109, 0, 68, 105, 114, 101, 99, 116, 111, 114, 121, 32, 110, 111, 116, 32, 101, 109, 112, 116, 121, 0, 67, 111,
				110, 110, 101, 99, 116, 105, 111, 110, 32, 114, 101, 115, 101, 116, 32, 98, 121, 32, 112, 101, 101, 114, 0, 79,
				112, 101, 114, 97, 116, 105, 111, 110, 32, 116, 105, 109, 101, 100, 32, 111, 117, 116, 0, 67, 111, 110, 110,
				101, 99, 116, 105, 111, 110, 32, 114, 101, 102, 117, 115, 101, 100, 0, 72, 111, 115, 116, 32, 105, 115, 32, 100,
				111, 119, 110, 0, 72, 111, 115, 116, 32, 105, 115, 32, 117, 110, 114, 101, 97, 99, 104, 97, 98, 108, 101, 0, 65,
				100, 100, 114, 101, 115, 115, 32, 105, 110, 32, 117, 115, 101, 0, 66, 114, 111, 107, 101, 110, 32, 112, 105,
				112, 101, 0, 73, 47, 79, 32, 101, 114, 114, 111, 114, 0, 78, 111, 32, 115, 117, 99, 104, 32, 100, 101, 118, 105,
				99, 101, 32, 111, 114, 32, 97, 100, 100, 114, 101, 115, 115, 0, 66, 108, 111, 99, 107, 32, 100, 101, 118, 105,
				99, 101, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0, 78, 111, 32, 115, 117, 99, 104, 32, 100, 101, 118, 105,
				99, 101, 0, 78, 111, 116, 32, 97, 32, 100, 105, 114, 101, 99, 116, 111, 114, 121, 0, 73, 115, 32, 97, 32, 100,
				105, 114, 101, 99, 116, 111, 114, 121, 0, 84, 101, 120, 116, 32, 102, 105, 108, 101, 32, 98, 117, 115, 121, 0,
				69, 120, 101, 99, 32, 102, 111, 114, 109, 97, 116, 32, 101, 114, 114, 111, 114, 0, 73, 110, 118, 97, 108, 105,
				100, 32, 97, 114, 103, 117, 109, 101, 110, 116, 0, 65, 114, 103, 117, 109, 101, 110, 116, 32, 108, 105, 115,
				116, 32, 116, 111, 111, 32, 108, 111, 110, 103, 0, 83, 121, 109, 98, 111, 108, 105, 99, 32, 108, 105, 110, 107,
				32, 108, 111, 111, 112, 0, 70, 105, 108, 101, 110, 97, 109, 101, 32, 116, 111, 111, 32, 108, 111, 110, 103, 0,
				84, 111, 111, 32, 109, 97, 110, 121, 32, 111, 112, 101, 110, 32, 102, 105, 108, 101, 115, 32, 105, 110, 32, 115,
				121, 115, 116, 101, 109, 0, 78, 111, 32, 102, 105, 108, 101, 32, 100, 101, 115, 99, 114, 105, 112, 116, 111,
				114, 115, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 66, 97, 100, 32, 102, 105, 108, 101, 32, 100, 101,
				115, 99, 114, 105, 112, 116, 111, 114, 0, 78, 111, 32, 99, 104, 105, 108, 100, 32, 112, 114, 111, 99, 101, 115,
				115, 0, 66, 97, 100, 32, 97, 100, 100, 114, 101, 115, 115, 0, 70, 105, 108, 101, 32, 116, 111, 111, 32, 108, 97,
				114, 103, 101, 0, 84, 111, 111, 32, 109, 97, 110, 121, 32, 108, 105, 110, 107, 115, 0, 78, 111, 32, 108, 111,
				99, 107, 115, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 82, 101, 115, 111, 117, 114, 99, 101, 32, 100,
				101, 97, 100, 108, 111, 99, 107, 32, 119, 111, 117, 108, 100, 32, 111, 99, 99, 117, 114, 0, 83, 116, 97, 116,
				101, 32, 110, 111, 116, 32, 114, 101, 99, 111, 118, 101, 114, 97, 98, 108, 101, 0, 80, 114, 101, 118, 105, 111,
				117, 115, 32, 111, 119, 110, 101, 114, 32, 100, 105, 101, 100, 0, 79, 112, 101, 114, 97, 116, 105, 111, 110, 32,
				99, 97, 110, 99, 101, 108, 101, 100, 0, 70, 117, 110, 99, 116, 105, 111, 110, 32, 110, 111, 116, 32, 105, 109,
				112, 108, 101, 109, 101, 110, 116, 101, 100, 0, 78, 111, 32, 109, 101, 115, 115, 97, 103, 101, 32, 111, 102, 32,
				100, 101, 115, 105, 114, 101, 100, 32, 116, 121, 112, 101, 0, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114,
				32, 114, 101, 109, 111, 118, 101, 100, 0, 68, 101, 118, 105, 99, 101, 32, 110, 111, 116, 32, 97, 32, 115, 116,
				114, 101, 97, 109, 0, 78, 111, 32, 100, 97, 116, 97, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 68, 101,
				118, 105, 99, 101, 32, 116, 105, 109, 101, 111, 117, 116, 0, 79, 117, 116, 32, 111, 102, 32, 115, 116, 114, 101,
				97, 109, 115, 32, 114, 101, 115, 111, 117, 114, 99, 101, 115, 0, 76, 105, 110, 107, 32, 104, 97, 115, 32, 98,
				101, 101, 110, 32, 115, 101, 118, 101, 114, 101, 100, 0, 80, 114, 111, 116, 111, 99, 111, 108, 32, 101, 114,
				114, 111, 114, 0, 66, 97, 100, 32, 109, 101, 115, 115, 97, 103, 101, 0, 70, 105, 108, 101, 32, 100, 101, 115,
				99, 114, 105, 112, 116, 111, 114, 32, 105, 110, 32, 98, 97, 100, 32, 115, 116, 97, 116, 101, 0, 78, 111, 116,
				32, 97, 32, 115, 111, 99, 107, 101, 116, 0, 68, 101, 115, 116, 105, 110, 97, 116, 105, 111, 110, 32, 97, 100,
				100, 114, 101, 115, 115, 32, 114, 101, 113, 117, 105, 114, 101, 100, 0, 77, 101, 115, 115, 97, 103, 101, 32,
				116, 111, 111, 32, 108, 97, 114, 103, 101, 0, 80, 114, 111, 116, 111, 99, 111, 108, 32, 119, 114, 111, 110, 103,
				32, 116, 121, 112, 101, 32, 102, 111, 114, 32, 115, 111, 99, 107, 101, 116, 0, 80, 114, 111, 116, 111, 99, 111,
				108, 32, 110, 111, 116, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 80, 114, 111, 116, 111, 99, 111, 108,
				32, 110, 111, 116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 0, 83, 111, 99, 107, 101, 116, 32, 116, 121,
				112, 101, 32, 110, 111, 116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 0, 78, 111, 116, 32, 115, 117,
				112, 112, 111, 114, 116, 101, 100, 0, 80, 114, 111, 116, 111, 99, 111, 108, 32, 102, 97, 109, 105, 108, 121, 32,
				110, 111, 116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 0, 65, 100, 100, 114, 101, 115, 115, 32, 102,
				97, 109, 105, 108, 121, 32, 110, 111, 116, 32, 115, 117, 112, 112, 111, 114, 116, 101, 100, 32, 98, 121, 32,
				112, 114, 111, 116, 111, 99, 111, 108, 0, 65, 100, 100, 114, 101, 115, 115, 32, 110, 111, 116, 32, 97, 118, 97,
				105, 108, 97, 98, 108, 101, 0, 78, 101, 116, 119, 111, 114, 107, 32, 105, 115, 32, 100, 111, 119, 110, 0, 78,
				101, 116, 119, 111, 114, 107, 32, 117, 110, 114, 101, 97, 99, 104, 97, 98, 108, 101, 0, 67, 111, 110, 110, 101,
				99, 116, 105, 111, 110, 32, 114, 101, 115, 101, 116, 32, 98, 121, 32, 110, 101, 116, 119, 111, 114, 107, 0, 67,
				111, 110, 110, 101, 99, 116, 105, 111, 110, 32, 97, 98, 111, 114, 116, 101, 100, 0, 78, 111, 32, 98, 117, 102,
				102, 101, 114, 32, 115, 112, 97, 99, 101, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 0, 83, 111, 99, 107, 101,
				116, 32, 105, 115, 32, 99, 111, 110, 110, 101, 99, 116, 101, 100, 0, 83, 111, 99, 107, 101, 116, 32, 110, 111,
				116, 32, 99, 111, 110, 110, 101, 99, 116, 101, 100, 0, 67, 97, 110, 110, 111, 116, 32, 115, 101, 110, 100, 32,
				97, 102, 116, 101, 114, 32, 115, 111, 99, 107, 101, 116, 32, 115, 104, 117, 116, 100, 111, 119, 110, 0, 79, 112,
				101, 114, 97, 116, 105, 111, 110, 32, 97, 108, 114, 101, 97, 100, 121, 32, 105, 110, 32, 112, 114, 111, 103,
				114, 101, 115, 115, 0, 79, 112, 101, 114, 97, 116, 105, 111, 110, 32, 105, 110, 32, 112, 114, 111, 103, 114,
				101, 115, 115, 0, 83, 116, 97, 108, 101, 32, 102, 105, 108, 101, 32, 104, 97, 110, 100, 108, 101, 0, 82, 101,
				109, 111, 116, 101, 32, 73, 47, 79, 32, 101, 114, 114, 111, 114, 0, 81, 117, 111, 116, 97, 32, 101, 120, 99,
				101, 101, 100, 101, 100, 0, 78, 111, 32, 109, 101, 100, 105, 117, 109, 32, 102, 111, 117, 110, 100, 0, 87, 114,
				111, 110, 103, 32, 109, 101, 100, 105, 117, 109, 32, 116, 121, 112, 101, 0, 78, 111, 32, 101, 114, 114, 111,
				114, 32, 105, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 0, 0, 17, 0, 10, 0, 17, 17, 17, 0, 0, 0, 0, 5, 0,
				0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 15, 10, 17, 17, 17, 3, 10, 7, 0, 1, 19, 9, 11,
				11, 0, 0, 9, 6, 11, 0, 0, 11, 0, 6, 17, 0, 0, 0, 17, 17, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
				0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 10, 10, 17, 17, 17, 0, 10, 0, 0, 2, 0, 9, 11, 0, 0, 0, 9, 0, 11, 0, 0, 11, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0,
				0, 0, 0, 12, 0, 0, 0, 0, 9, 12, 0, 0, 0, 0, 0, 12, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 4, 13, 0, 0, 0, 0, 9, 14, 0, 0, 0, 0,
				0, 14, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 15, 0, 0, 0, 0, 9, 16, 0, 0, 0, 0, 0, 16, 0, 0, 16, 0, 0, 18, 0, 0, 0, 18, 18,
				18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 18, 18, 18, 0, 0, 0,
				0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 10, 0, 0, 0, 0, 9, 11, 0, 0, 0, 0, 0, 11, 0, 0, 11,
				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				12, 0, 0, 0, 0, 12, 0, 0, 0, 0, 9, 12, 0, 0, 0, 0, 0, 12, 0, 0, 12, 0, 0, 45, 43, 32, 32, 32, 48, 88, 48, 120,
				0, 40, 110, 117, 108, 108, 41, 0, 45, 48, 88, 43, 48, 88, 32, 48, 88, 45, 48, 120, 43, 48, 120, 32, 48, 120, 0,
				105, 110, 102, 0, 73, 78, 70, 0, 110, 97, 110, 0, 78, 65, 78, 0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66,
				67, 68, 69, 70, 46, 0
			], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
		var tempDoublePtr = STATICTOP;

		function ___lock() {}

		function ___unlock() {}
		STATICTOP += 16, assert(tempDoublePtr % 8 == 0);
		var SYSCALLS = {
			varargs: 0,
			get: function(e) {
				return SYSCALLS.varargs += 4, HEAP32[SYSCALLS.varargs - 4 >> 2]
			},
			getStr: function() {
				return Pointer_stringify(SYSCALLS.get())
			},
			get64: function() {
				var e = SYSCALLS.get(),
					t = SYSCALLS.get();
				return assert(e >= 0 ? 0 === t : -1 === t), e
			},
			getZero: function() {
				assert(0 === SYSCALLS.get())
			}
		};

		function ___syscall6(e, t) {
			SYSCALLS.varargs = t;
			try {
				var r = SYSCALLS.getStreamFromFD();
				return FS.close(r), 0
			} catch (e) {
				return void 0 !== FS && e instanceof FS.ErrnoError || abort(e), -e.errno
			}
		}
		var cttz_i8 = allocate([8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0,
			1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1,
			0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0,
			3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2,
			0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0,
			1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1,
			0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0,
			2, 0, 1, 0
		], "i8", ALLOC_STATIC);

		function ___setErrNo(e) {
			return Module.___errno_location ? HEAP32[Module.___errno_location() >> 2] = e : Module.printErr(
				"failed to set errno from JS"), e
		}

		function _emscripten_memcpy_big(e, t, r) {
			return HEAPU8.set(HEAPU8.subarray(t, t + r), e), e
		}

		function ___syscall140(e, t) {
			SYSCALLS.varargs = t;
			try {
				var r = SYSCALLS.getStreamFromFD(),
					n = (SYSCALLS.get(), SYSCALLS.get()),
					i = SYSCALLS.get(),
					o = SYSCALLS.get(),
					a = n;
				return FS.llseek(r, a, o), HEAP32[i >> 2] = r.position, r.getdents && 0 === a && 0 === o && (r.getdents = null),
					0
			} catch (e) {
				return void 0 !== FS && e instanceof FS.ErrnoError || abort(e), -e.errno
			}
		}

		function ___syscall146(e, t) {
			SYSCALLS.varargs = t;
			try {
				var r = SYSCALLS.get(),
					n = SYSCALLS.get(),
					i = SYSCALLS.get(),
					o = 0;
				___syscall146.buffer || (___syscall146.buffers = [null, [],
					[]
				], ___syscall146.printChar = function(e, t) {
					var r = ___syscall146.buffers[e];
					assert(r), 0 === t || 10 === t ? ((1 === e ? Module.print : Module.printErr)(UTF8ArrayToString(r, 0)), r.length =
						0) : r.push(t)
				});
				for (var a = 0; a < i; a++) {
					for (var u = HEAP32[n + 8 * a >> 2], s = HEAP32[n + (8 * a + 4) >> 2], f = 0; f < s; f++) ___syscall146.printChar(
						r, HEAPU8[u + f]);
					o += s
				}
				return o
			} catch (e) {
				return void 0 !== FS && e instanceof FS.ErrnoError || abort(e), -e.errno
			}
		}

		function ___syscall54(e, t) {
			SYSCALLS.varargs = t;
			try {
				return 0
			} catch (e) {
				return void 0 !== FS && e instanceof FS.ErrnoError || abort(e), -e.errno
			}
		}

		function nullFunc_ii(e) {
			Module.printErr(
				"Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"
			), Module.printErr("Build with ASSERTIONS=2 for more info."), abort(e)
		}

		function nullFunc_iiii(e) {
			Module.printErr(
				"Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"
			), Module.printErr("Build with ASSERTIONS=2 for more info."), abort(e)
		}

		function invoke_ii(e, t) {
			try {
				return Module.dynCall_ii(e, t)
			} catch (e) {
				if ("number" != typeof e && "longjmp" !== e) throw e;
				Module.setThrew(1, 0)
			}
		}

		function invoke_iiii(e, t, r, n) {
			try {
				return Module.dynCall_iiii(e, t, r, n)
			} catch (e) {
				if ("number" != typeof e && "longjmp" !== e) throw e;
				Module.setThrew(1, 0)
			}
		}
		__ATEXIT__.push(function() {
				var e = Module._fflush;
				e && e(0);
				var t = ___syscall146.printChar;
				if (t) {
					var r = ___syscall146.buffers;
					r[1].length && t(1, 10), r[2].length && t(2, 10)
				}
			}), DYNAMICTOP_PTR = allocate(1, "i32", ALLOC_STATIC), STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP),
			STACK_MAX = STACK_BASE + TOTAL_STACK, DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX), HEAP32[DYNAMICTOP_PTR >> 2] =
			DYNAMIC_BASE, staticSealed = !0, assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack"),
			Module.asmGlobalArg = {
				Math: Math,
				Int8Array: Int8Array,
				Int16Array: Int16Array,
				Int32Array: Int32Array,
				Uint8Array: Uint8Array,
				Uint16Array: Uint16Array,
				Uint32Array: Uint32Array,
				Float32Array: Float32Array,
				Float64Array: Float64Array,
				NaN: NaN,
				Infinity: 1 / 0
			}, Module.asmLibraryArg = {
				abort: abort,
				assert: assert,
				enlargeMemory: enlargeMemory,
				getTotalMemory: getTotalMemory,
				abortOnCannotGrowMemory: abortOnCannotGrowMemory,
				abortStackOverflow: abortStackOverflow,
				nullFunc_ii: nullFunc_ii,
				nullFunc_iiii: nullFunc_iiii,
				invoke_ii: invoke_ii,
				invoke_iiii: invoke_iiii,
				___lock: ___lock,
				___syscall6: ___syscall6,
				___setErrNo: ___setErrNo,
				___syscall140: ___syscall140,
				_emscripten_memcpy_big: _emscripten_memcpy_big,
				___syscall54: ___syscall54,
				___unlock: ___unlock,
				___syscall146: ___syscall146,
				DYNAMICTOP_PTR: DYNAMICTOP_PTR,
				tempDoublePtr: tempDoublePtr,
				ABORT: ABORT,
				STACKTOP: STACKTOP,
				STACK_MAX: STACK_MAX,
				cttz_i8: cttz_i8
			};
		var asm = function(e, t, r) {
				var n = new e.Int8Array(r),
					i = new e.Int16Array(r),
					o = new e.Int32Array(r),
					a = (new e.Uint8Array(r), new e.Uint16Array(r), new e.Uint32Array(r), new e.Float32Array(r), new e.Float64Array(
						r)),
					u = 0 | t.DYNAMICTOP_PTR,
					s = 0 | t.tempDoublePtr,
					f = (t.ABORT, 0 | t.STACKTOP),
					l = 0 | t.STACK_MAX,
					c = 0 | t.cttz_i8,
					d = (e.NaN, e.Infinity, 0),
					h = (e.Math.floor, e.Math.abs, e.Math.sqrt, e.Math.pow, e.Math.cos, e.Math.sin, e.Math.tan, e.Math.acos, e.Math
						.asin, e.Math.atan, e.Math.atan2, e.Math.exp, e.Math.log, e.Math.ceil, e.Math.imul),
					p = (e.Math.min, e.Math.max, e.Math.clz32),
					_ = (t.abort, t.assert, t.enlargeMemory),
					m = t.getTotalMemory,
					y = t.abortOnCannotGrowMemory,
					g = t.abortStackOverflow,
					b = t.nullFunc_ii,
					v = t.nullFunc_iiii,
					A = (t.invoke_ii, t.invoke_iiii, t.___lock),
					T = t.___syscall6,
					w = t.___setErrNo,
					E = t.___syscall140,
					M = t._emscripten_memcpy_big,
					S = t.___syscall54,
					k = t.___unlock,
					R = t.___syscall146;

				function I(e, t) {
					e |= 0, t |= 0;
					var r, i, o, a = 0,
						u = 0;
					for (o = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), r = e, i = t, u = 0;
						(0 | 255 & u) < 16;) a = 0 | n[(i + (255 & u) | 0) >> 0], n[(r + (255 & u) | 0) >> 0] = a, u = u + 1 << 24 >>
						24;
					f = o
				}

				function O() {
					var e, t, r = 0,
						i = 0,
						a = 0,
						u = 0,
						s = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0;
					for (t = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), e = t + 12 | 0, r = 0; r >>> 0 < 4;) E = 0 | o[1019], u =
						0 | n[(E + ((r << 2) + 0 | 0) | 0) >> 0], n[(4656 + ((r << 2) + 0 | 0) | 0) >> 0] = u, p = 0 | o[1019], m = 0 |
						n[(p + ((r << 2) + 1 | 0) | 0) >> 0], n[(4656 + ((r << 2) + 1 | 0) | 0) >> 0] = m, y = 0 | o[1019], b = 0 | n[
							(y + ((r << 2) + 2 | 0) | 0) >> 0], n[(4656 + ((r << 2) + 2 | 0) | 0) >> 0] = b, v = 0 | o[1019], A = 0 | n[(
							v + ((r << 2) + 3 | 0) | 0) >> 0], n[(4656 + ((r << 2) + 3 | 0) | 0) >> 0] = A, r = r + 1 | 0;
					for (; r >>> 0 < 44;) {
						for (i = 0; T = r, i >>> 0 < 4;) w = 0 | n[(4656 + (((T - 1 | 0) << 2) + i | 0) | 0) >> 0], n[(e + i | 0) >> 0] =
							w, i = i + 1 | 0;
						0 == (0 | (T >>> 0) % 4 & -1) && (_ = 255 & (0 | n[e >> 0]), M = 0 | n[(e + 1 | 0) >> 0], n[e >> 0] = M, S = 0 |
								n[(e + 2 | 0) >> 0], n[(e + 1 | 0) >> 0] = S, k = 0 | n[(e + 3 | 0) >> 0], n[(e + 2 | 0) >> 0] = k, R = 255 &
								_, n[(e + 3 | 0) >> 0] = R, I = 0 | L(0 | n[e >> 0]), n[e >> 0] = I, O = 0 | L(0 | n[(e + 1 | 0) >> 0]), n[(
									e + 1 | 0) >> 0] = O, P = 0 | L(0 | n[(e + 2 | 0) >> 0]), n[(e + 2 | 0) >> 0] = P, B = 0 | L(0 | n[(e + 3 |
									0) >> 0]), n[(e + 3 | 0) >> 0] = B, a = 255 & (255 & (0 | n[e >> 0]) ^ 255 & (0 | n[(504 + ((r >>> 0) / 4 &
									-1) | 0) >> 0])), n[e >> 0] = a), s = 255 & (255 & (0 | n[(4656 + (((r - 4 | 0) << 2) + 0 | 0) | 0) >> 0]) ^
								255 & (0 | n[e >> 0])), n[(4656 + ((r << 2) + 0 | 0) | 0) >> 0] = s, c = 255 & (255 & (0 | n[(4656 + (((r -
								4 | 0) << 2) + 1 | 0) | 0) >> 0]) ^ 255 & (0 | n[(e + 1 | 0) >> 0])), n[(4656 + ((r << 2) + 1 | 0) | 0) >> 0] =
							c, d = 255 & (255 & (0 | n[(4656 + (((r - 4 | 0) << 2) + 2 | 0) | 0) >> 0]) ^ 255 & (0 | n[(e + 2 | 0) >> 0])),
							n[(4656 + ((r << 2) + 2 | 0) | 0) >> 0] = d, h = 255 & (255 & (0 | n[(4656 + (((r - 4 | 0) << 2) + 3 | 0) | 0) >>
								0]) ^ 255 & (0 | n[(e + 3 | 0) >> 0])), n[(4656 + ((r << 2) + 3 | 0) | 0) >> 0] = h, r = r + 1 | 0
					}
					f = t
				}

				function P() {
					var e, t = 0,
						r = 0;
					for (e = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = 0, N(10), t = 9; r = (0 | 255 & t) > 0, U(), F(), r;)
						N(t), D(), t = t + -1 << 24 >> 24;
					N(0), f = e
				}

				function B(e) {
					e |= 0;
					var t, r, i = 0,
						a = 0,
						u = 0,
						s = 0,
						c = 0;
					for (r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = e, s = 0;
						(0 | 255 & s) < 16;) c = 0 | o[1020], i = 255 & (0 | n[(c + (255 & s) | 0) >> 0]), u = 255 & (255 & (0 | n[(a =
						t + (255 & s) | 0) >> 0]) ^ i), n[a >> 0] = u, s = s + 1 << 24 >> 24;
					f = r
				}

				function C(e, t, r, n, i) {
					e |= 0, t |= 0, r |= 0, n |= 0, i |= 0;
					var a, u, s, c, d, h, p, _ = 0,
						m = 0,
						y = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0;
					for (p = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), d = n, h = i, a = 255 & (((c = r) >>> 0) % 16 & -1), I(
							A = e, T = t), u = A, o[1018] = u, 0 != (0 | d) && (m = d, o[1019] = m, O()), 0 != (0 | h) && (y = h, o[1020] =
							y), _ = 0; _ >>> 0 < c >>> 0;) I(A, T), b = A, o[1018] = b, P(), B(A), v = T, o[1020] = v, T = T + 16 | 0, A =
						A + 16 | 0, _ = _ + 16 | 0;
					a << 24 >> 24 != 0 ? (I(A, T), Me(0 | (A + (255 & a) | 0), 0, 0 | (16 - (255 & a) | 0)), s = A, o[1018] = s, P(),
						f = p) : f = p
				}

				function L(e) {
					e |= 0;
					var t, r;
					return r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = 0 | n[(759 + (255 & e) | 0) >> 0], f = r, 0 | t
				}

				function N(e) {
					e |= 0;
					var t, r, i = 0,
						a = 0,
						u = 0,
						s = 0,
						c = 0,
						d = 0;
					for (r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = e, i = 0;
						(0 | 255 & i) < 4;) {
						for (s = 0;
							(0 | 255 & s) < 4;) a = 255 & (0 | n[(4656 + ((((255 & t) << 2 << 2) + ((255 & i) << 2) | 0) + (255 & s) | 0) |
							0) >> 0]), u = 0 | o[1018], d = 255 & (255 & (0 | n[(c = (u + ((255 & i) << 2) | 0) + (255 & s) | 0) >> 0]) ^
							a), n[c >> 0] = d, s = s + 1 << 24 >> 24;
						i = i + 1 << 24 >> 24
					}
					f = r
				}

				function x(e) {
					e |= 0;
					var t, r;
					return r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), f = r, 0 | 255 & ((255 & (t = e)) << 1 ^ (27 * (1 & (
						255 & t) >> 7) | 0))
				}

				function U() {
					var e, t, r, i, a, u, s, c, d, h, p, _, m, y, b, v, A, T, w, E, M, S, k, R, I, O, P, B, C, L, N, x, U, F, D, Y,
						H, j = 0;
					H = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), e = 0 | o[1018], j = 0 | n[((e + 12 | 0) + 1 | 0) >> 0], E =
						0 | o[1018], F = 0 | n[((E + 8 | 0) + 1 | 0) >> 0], Y = 0 | o[1018], n[((Y + 12 | 0) + 1 | 0) >> 0] = F, t = 0 |
						o[1018], r = 0 | n[((t + 4 | 0) + 1 | 0) >> 0], i = 0 | o[1018], n[((i + 8 | 0) + 1 | 0) >> 0] = r, a = 0 | o[
							1018], u = 0 | n[(a + 1 | 0) >> 0], s = 0 | o[1018], n[((s + 4 | 0) + 1 | 0) >> 0] = u, c = j, d = 0 | o[1018],
						n[(d + 1 | 0) >> 0] = c, h = 0 | o[1018], j = 0 | n[(h + 2 | 0) >> 0], p = 0 | o[1018], _ = 0 | n[((p + 8 | 0) +
							2 | 0) >> 0], m = 0 | o[1018], n[(m + 2 | 0) >> 0] = _, y = j, b = 0 | o[1018], n[((b + 8 | 0) + 2 | 0) >> 0] =
						y, v = 0 | o[1018], j = 0 | n[((v + 4 | 0) + 2 | 0) >> 0], A = 0 | o[1018], T = 0 | n[((A + 12 | 0) + 2 | 0) >>
							0], w = 0 | o[1018], n[((w + 4 | 0) + 2 | 0) >> 0] = T, M = j, S = 0 | o[1018], n[((S + 12 | 0) + 2 | 0) >> 0] =
						M, k = 0 | o[1018], j = 0 | n[(k + 3 | 0) >> 0], R = 0 | o[1018], I = 0 | n[((R + 4 | 0) + 3 | 0) >> 0], O = 0 |
						o[1018], n[(O + 3 | 0) >> 0] = I, P = 0 | o[1018], B = 0 | n[((P + 8 | 0) + 3 | 0) >> 0], C = 0 | o[1018], n[(
							(C + 4 | 0) + 3 | 0) >> 0] = B, L = 0 | o[1018], N = 0 | n[((L + 12 | 0) + 3 | 0) >> 0], x = 0 | o[1018], n[(
							(x + 8 | 0) + 3 | 0) >> 0] = N, U = j, D = 0 | o[1018], n[((D + 12 | 0) + 3 | 0) >> 0] = U, f = H
				}

				function F() {
					var e, t = 0,
						r = 0,
						i = 0,
						a = 0,
						u = 0;
					for (e = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = 0;
						(0 | 255 & t) < 4;) {
						for (r = 0;
							(0 | 255 & r) < 4;) u = 0 | o[1018], i = 0 | Y(0 | n[((u + ((255 & r) << 2) | 0) + (255 & t) | 0) >> 0]), a =
							0 | o[1018], n[((a + ((255 & r) << 2) | 0) + (255 & t) | 0) >> 0] = i, r = r + 1 << 24 >> 24;
						t = t + 1 << 24 >> 24
					}
					f = e
				}

				function D() {
					var e, t = 0,
						r = 0,
						i = 0,
						a = 0,
						u = 0,
						s = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						q = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						se = 0,
						fe = 0,
						le = 0,
						ce = 0,
						de = 0,
						he = 0,
						pe = 0,
						_e = 0,
						me = 0,
						ye = 0,
						ge = 0,
						be = 0,
						ve = 0,
						Ae = 0,
						Te = 0,
						we = 0,
						Ee = 0,
						Me = 0,
						Se = 0,
						ke = 0,
						Re = 0,
						Ie = 0,
						Oe = 0,
						Pe = 0,
						Be = 0,
						Ce = 0,
						Le = 0,
						Ne = 0,
						xe = 0,
						Ue = 0,
						Fe = 0,
						De = 0,
						Ye = 0,
						He = 0,
						je = 0,
						We = 0,
						ze = 0,
						Ve = 0,
						Ke = 0,
						Xe = 0,
						Ge = 0,
						Je = 0,
						$e = 0,
						qe = 0,
						Ze = 0,
						Qe = 0,
						et = 0,
						tt = 0,
						rt = 0,
						nt = 0,
						it = 0,
						ot = 0,
						at = 0,
						ut = 0,
						st = 0,
						ft = 0,
						lt = 0,
						ct = 0,
						dt = 0,
						ht = 0,
						pt = 0,
						_t = 0,
						mt = 0,
						yt = 0,
						gt = 0,
						bt = 0,
						vt = 0,
						At = 0,
						Tt = 0,
						wt = 0,
						Et = 0,
						Mt = 0,
						St = 0,
						kt = 0,
						Rt = 0,
						It = 0,
						Ot = 0,
						Pt = 0,
						Bt = 0,
						Ct = 0,
						Lt = 0,
						Nt = 0,
						xt = 0,
						Ut = 0,
						Ft = 0,
						Dt = 0,
						Yt = 0,
						Ht = 0,
						jt = 0,
						Wt = 0,
						zt = 0,
						Vt = 0,
						Kt = 0,
						Xt = 0,
						Gt = 0,
						Jt = 0,
						$t = 0,
						qt = 0,
						Zt = 0,
						Qt = 0,
						er = 0,
						tr = 0,
						rr = 0,
						nr = 0,
						ir = 0,
						or = 0,
						ar = 0,
						ur = 0,
						sr = 0,
						fr = 0,
						lr = 0,
						cr = 0,
						dr = 0,
						hr = 0,
						pr = 0,
						_r = 0,
						mr = 0,
						yr = 0,
						gr = 0,
						br = 0,
						vr = 0,
						Ar = 0,
						Tr = 0,
						wr = 0,
						Er = 0,
						Mr = 0;
					for (e = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = 0;
						(0 | t) < 4;) pr = 0 | o[1018], r = 0 | n[(pr + (t << 2) | 0) >> 0], h = 0 | o[1018], X = 0 | n[((h + (t << 2) |
							0) + 1 | 0) >> 0], P = 0 | o[1018], Pe = 0 | n[((P + (t << 2) | 0) + 2 | 0) >> 0], Z = 0 | o[1018], pt = 0 |
						n[((Z + (t << 2) | 0) + 3 | 0) >> 0], We = 0 ^ 255 & (0 | x(r)), $e = 0 | x(r), ct = We ^ 255 & (0 | x($e)),
						yt = 0 | x(r), wt = 0 | x(yt), Dt = ct ^ 255 & (0 | x(wt)), Gt = 0 | x(r), qt = 0 | x(Gt), tr = 0 | x(qt), 0 |
						x(tr), lr = Dt ^ 0, cr = 255 & X ^ 255 & (0 | x(X)), dr = 0 | x(X), 0 | x(dr), hr = cr ^ 0, _r = 0 | x(X), mr =
						0 | x(_r), yr = hr ^ 255 & (0 | x(mr)), gr = 0 | x(X), br = 0 | x(gr), vr = 0 | x(br), 0 | x(vr), Ar = lr ^ (
							yr ^ 0), Tr = 255 & Pe, 0 | x(Pe), wr = Tr ^ 0, Er = 0 | x(Pe), Mr = wr ^ 255 & (0 | x(Er)), i = 0 | x(Pe), a =
						0 | x(i), u = Mr ^ 255 & (0 | x(a)), s = 0 | x(Pe), c = 0 | x(s), d = 0 | x(c), 0 | x(d), p = Ar ^ (u ^ 0), _ =
						255 & pt, 0 | x(pt), m = _ ^ 0, y = 0 | x(pt), 0 | x(y), b = m ^ 0, v = 0 | x(pt), A = 0 | x(v), T = b ^ 255 &
						(0 | x(A)), w = 0 | x(pt), E = 0 | x(w), M = 0 | x(E), 0 | x(M), S = 255 & (p ^ (T ^ 0)), k = 0 | o[1018], n[(
							k + (t << 2) | 0) >> 0] = S, R = 255 & r, 0 | x(r), I = R ^ 0, O = 0 | x(r), 0 | x(O), B = I ^ 0, C = 0 | x(r),
						L = 0 | x(C), N = B ^ 255 & (0 | x(L)), U = 0 | x(r), F = 0 | x(U), D = 0 | x(F), 0 | x(D), Y = N ^ 0, H = 0 ^
						255 & (0 | x(X)), j = 0 | x(X), W = H ^ 255 & (0 | x(j)), z = 0 | x(X), V = 0 | x(z), K = W ^ 255 & (0 | x(V)),
						G = 0 | x(X), J = 0 | x(G), $ = 0 | x(J), 0 | x($), q = Y ^ (K ^ 0), Q = 255 & Pe ^ 255 & (0 | x(Pe)), ee = 0 |
						x(Pe), 0 | x(ee), te = Q ^ 0, re = 0 | x(Pe), ne = 0 | x(re), ie = te ^ 255 & (0 | x(ne)), oe = 0 | x(Pe), ae =
						0 | x(oe), ue = 0 | x(ae), 0 | x(ue), se = q ^ (ie ^ 0), fe = 255 & pt, 0 | x(pt), le = fe ^ 0, ce = 0 | x(pt),
						de = le ^ 255 & (0 | x(ce)), he = 0 | x(pt), pe = 0 | x(he), _e = de ^ 255 & (0 | x(pe)), me = 0 | x(pt), ye =
						0 | x(me), ge = 0 | x(ye), 0 | x(ge), be = 255 & (se ^ (_e ^ 0)), ve = 0 | o[1018], n[((ve + (t << 2) | 0) + 1 |
							0) >> 0] = be, Ae = 255 & r, 0 | x(r), Te = Ae ^ 0, we = 0 | x(r), Ee = Te ^ 255 & (0 | x(we)), Me = 0 | x(r),
						Se = 0 | x(Me), ke = Ee ^ 255 & (0 | x(Se)), Re = 0 | x(r), Ie = 0 | x(Re), Oe = 0 | x(Ie), 0 | x(Oe), Be = ke ^
						0, Ce = 255 & X, 0 | x(X), Le = Ce ^ 0, Ne = 0 | x(X), 0 | x(Ne), xe = Le ^ 0, Ue = 0 | x(X), Fe = 0 | x(Ue),
						De = xe ^ 255 & (0 | x(Fe)), Ye = 0 | x(X), He = 0 | x(Ye), je = 0 | x(He), 0 | x(je), ze = Be ^ (De ^ 0), Ve =
						0 ^ 255 & (0 | x(Pe)), Ke = 0 | x(Pe), Xe = Ve ^ 255 & (0 | x(Ke)), Ge = 0 | x(Pe), Je = 0 | x(Ge), qe = Xe ^
						255 & (0 | x(Je)), Ze = 0 | x(Pe), Qe = 0 | x(Ze), et = 0 | x(Qe), 0 | x(et), tt = ze ^ (qe ^ 0), rt = 255 &
						pt ^ 255 & (0 | x(pt)), nt = 0 | x(pt), 0 | x(nt), it = rt ^ 0, ot = 0 | x(pt), at = 0 | x(ot), ut = it ^ 255 &
						(0 | x(at)), st = 0 | x(pt), ft = 0 | x(st), lt = 0 | x(ft), 0 | x(lt), dt = 255 & (tt ^ (ut ^ 0)), ht = 0 | o[
							1018], n[((ht + (t << 2) | 0) + 2 | 0) >> 0] = dt, _t = 255 & r ^ 255 & (0 | x(r)), mt = 0 | x(r), 0 | x(mt),
						gt = _t ^ 0, bt = 0 | x(r), vt = 0 | x(bt), At = gt ^ 255 & (0 | x(vt)), Tt = 0 | x(r), Et = 0 | x(Tt), Mt = 0 |
						x(Et), 0 | x(Mt), St = At ^ 0, kt = 255 & X, 0 | x(X), Rt = kt ^ 0, It = 0 | x(X), Ot = Rt ^ 255 & (0 | x(It)),
						Pt = 0 | x(X), Bt = 0 | x(Pt), Ct = Ot ^ 255 & (0 | x(Bt)), Lt = 0 | x(X), Nt = 0 | x(Lt), xt = 0 | x(Nt), 0 |
						x(xt), Ut = St ^ (Ct ^ 0), Ft = 255 & Pe, 0 | x(Pe), Yt = Ft ^ 0, Ht = 0 | x(Pe), 0 | x(Ht), jt = Yt ^ 0, Wt =
						0 | x(Pe), zt = 0 | x(Wt), Vt = jt ^ 255 & (0 | x(zt)), Kt = 0 | x(Pe), Xt = 0 | x(Kt), Jt = 0 | x(Xt), 0 | x(
							Jt), $t = Ut ^ (Vt ^ 0), Zt = 0 ^ 255 & (0 | x(pt)), Qt = 0 | x(pt), er = Zt ^ 255 & (0 | x(Qt)), rr = 0 | x(
							pt), nr = 0 | x(rr), ir = er ^ 255 & (0 | x(nr)), or = 0 | x(pt), ar = 0 | x(or), ur = 0 | x(ar), 0 | x(ur),
						sr = 255 & ($t ^ (ir ^ 0)), fr = 0 | o[1018], n[((fr + (t << 2) | 0) + 3 | 0) >> 0] = sr, t = t + 1 | 0;
					f = e
				}

				function Y(e) {
					e |= 0;
					var t, r;
					return r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = 0 | n[(1015 + (255 & e) | 0) >> 0], f = r, 0 | t
				}

				function H(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var n, i, a, u, s, c, d, h, p, _, m, y = 0,
						b = 0,
						v = 0,
						A = 0;
					if (m = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), h = t, p = r, v = 0, A = 0, 0, _ = 64 - (A = 63 & (0 | o[
							(u = e) >> 2]) >>> 3) | 0, n = p << 3, a = (0 | o[(i = u) >> 2]) + n | 0, o[i >> 2] = a, (0 | o[u >> 2]) >>>
						0 < p << 3 >>> 0 && (b = (0 | o[(y = u + 4 | 0) >> 2]) + 1 | 0, o[y >> 2] = b), s = p >>> 29, d = (0 | o[(c =
							u + 4 | 0) >> 2]) + s | 0, o[c >> 2] = d, !(p >>> 0 >= _ >>> 0)) return Ce(0 | ((u + 24 | 0) + A | 0), 0 | (h +
						(v = 0) | 0), 0 | (p - v | 0)), void(f = m);
					for (Ce(0 | ((u + 24 | 0) + A | 0), 0 | h, 0 | _), j(u + 8 | 0, u + 24 | 0), v = _;
						(v + 64 | 0) >>> 0 <= p >>> 0;) j(u + 8 | 0, h + v | 0), v = v + 64 | 0;
					Ce(0 | ((u + 24 | 0) + (A = 0) | 0), 0 | (h + v | 0), 0 | (p - v | 0)), f = m
				}

				function j(e, t) {
					e |= 0, t |= 0;
					var r, n, i, a, u, s, c, d, h, p, _, m, y, b, v, A, T = 0,
						w = 0,
						E = 0,
						M = 0;
					A = f, (0 | (f = f + 288 | 0)) >= (0 | l) && g(288), v = A, b = t, T = 0 | o[(y = e) >> 2], w = 0 | o[(y + 4 |
							0) >> 2], E = 0 | o[(y + 8 | 0) >> 2], M = 0 | o[(y + 12 | 0) >> 2], W(v, b, 64), w = (w = (w = (w = (w = (w =
							(w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w =
												(w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w = (w =
															(w = (w = (w = (w = w + ((((E = (E = (E = E + ((((M = (M = (M = M +
																			((((T = (T = (T = T + (((w & E | (-1 ^ w) & M) + (0 |
																					o[v >> 2]) | 0) + -680876936 | 0) | 0) << 7 |
																				T >>> 25) + w | 0) & w | (-1 ^ T) & E) + (0 | o[
																				(v + 4 | 0) >> 2]) | 0) + -389564586 | 0) | 0) <<
																		12 | M >>> 20) + T | 0) & T | (-1 ^ M) & w) + (0 | o[(
																		v + 8 | 0) >> 2]) | 0) + 606105819 | 0) | 0) << 17 | E >>>
																	15) + M | 0) & M | (-1 ^ E) & T) + (0 | o[(v + 12 | 0) >> 2]) |
																0) + -1044525330 | 0) | 0) << 22 | w >>> 10) + E | 0) + ((((E = (
																	E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w &
																							E | (-1 ^ w) & M) + (0 | o[(v + 16 | 0) >> 2]) |
																						0) + -176418897 | 0) | 0) << 7 | T >>> 25) + w |
																					0) & w | (-1 ^ T) & E) + (0 | o[(v + 20 | 0) >> 2]) |
																				0) + 1200080426 | 0) | 0) << 12 | M >>> 20) + T | 0) & T |
																			(-1 ^ M) & w) + (0 | o[(v + 24 | 0) >> 2]) | 0) + -
																		1473231341 | 0) | 0) << 17 | E >>> 15) + M | 0) & M | (-1 ^ E) &
																T) + (0 | o[(v + 28 | 0) >> 2]) | 0) + -45705983 | 0) | 0) << 22 |
															w >>> 10) + E | 0) + ((((E = (E = (E = E + ((((M = (M = (M = M + (((
																		(T = (T = (T = T + (((w & E | (-1 ^ w) & M) + (0 | o[(
																				v + 32 | 0) >> 2]) | 0) + 1770035416 | 0) | 0) << 7 |
																			T >>> 25) + w | 0) & w | (-1 ^ T) & E) + (0 | o[(v +
																		36 | 0) >> 2]) | 0) + -1958414417 | 0) | 0) << 12 | M >>>
																	20) + T | 0) & T | (-1 ^ M) & w) + (0 | o[(v + 40 | 0) >> 2]) |
																0) + -42063 | 0) | 0) << 17 | E >>> 15) + M | 0) & M | (-1 ^ E) &
															T) + (0 | o[(v + 44 | 0) >> 2]) | 0) + -1990404162 | 0) | 0) << 22 |
														w >>> 10) + E | 0) + ((((E = (E = (E = E + ((((M = (M = (M = M + ((((T =
																(T = (T = T + (((w & E | (-1 ^ w) & M) + (0 | o[(v + 48 |
																	0) >> 2]) | 0) + 1804603682 | 0) | 0) << 7 | T >>> 25) +
																w | 0) & w | (-1 ^ T) & E) + (0 | o[(v + 52 | 0) >> 2]) |
															0) + -40341101 | 0) | 0) << 12 | M >>> 20) + T | 0) & T | (-1 ^
															M) & w) + (0 | o[(v + 56 | 0) >> 2]) | 0) + -1502002290 | 0) | 0) <<
														17 | E >>> 15) + M | 0) & M | (-1 ^ E) & T) + (0 | o[(v + 60 | 0) >>
														2]) | 0) + 1236535329 | 0) | 0) << 22 | w >>> 10) + E | 0) + ((((E = (E =
														(E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w & M | E & (-
																		1 ^ M)) + (0 | o[(v + 4 | 0) >> 2]) | 0) + -165796510 |
																	0) | 0) << 5 | T >>> 27) + w | 0) & E | w & (-1 ^ E)) + (0 |
																	o[(v + 24 | 0) >> 2]) | 0) + -1069501632 | 0) | 0) << 9 | M >>>
																23) + T | 0) & w | T & (-1 ^ w)) + (0 | o[(v + 44 | 0) >> 2]) | 0) +
															643717713 | 0) | 0) << 14 | E >>> 18) + M | 0) & T | M & (-1 ^ T)) + (0 |
														o[v >> 2]) | 0) + -373897302 | 0) | 0) << 20 | w >>> 12) + E | 0) + ((((E = (
														E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w & M | E & (
																		-1 ^ M)) + (0 | o[(v + 20 | 0) >> 2]) | 0) + -701558691 |
																	0) | 0) << 5 | T >>> 27) + w | 0) & E | w & (-1 ^ E)) + (0 | o[
																	(v + 40 | 0) >> 2]) | 0) + 38016083 | 0) | 0) << 9 | M >>> 23) + T |
																0) & w | T & (-1 ^ w)) + (0 | o[(v + 60 | 0) >> 2]) | 0) + -660478335 |
															0) | 0) << 14 | E >>> 18) + M | 0) & T | M & (-1 ^ T)) + (0 | o[(v + 16 |
														0) >> 2]) | 0) + -405537848 | 0) | 0) << 20 | w >>> 12) + E | 0) + ((((E = (E =
															(E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w & M | E & (-1 ^ M)) +
																		(0 | o[(v + 36 | 0) >> 2]) | 0) + 568446438 | 0) | 0) << 5 | T >>>
																	27) + w | 0) & E | w & (-1 ^ E)) + (0 | o[(v + 56 | 0) >> 2]) | 0) +
																-1019803690 | 0) | 0) << 9 | M >>> 23) + T | 0) & w | T & (-1 ^ w)) + (0 |
																o[(v + 12 | 0) >> 2]) | 0) + -187363961 | 0) | 0) << 14 | E >>> 18) + M | 0) &
														T | M & (-1 ^ T)) + (0 | o[(v + 32 | 0) >> 2]) | 0) + 1163531501 | 0) | 0) << 20 |
													w >>> 12) + E | 0) + ((((E = (E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T =
																	T + (((w & M | E & (-1 ^ M)) + (0 | o[(v + 52 | 0) >> 2]) | 0) + -
																		1444681467 | 0) | 0) << 5 | T >>> 27) + w | 0) & E | w & (-1 ^ E)) +
																(0 | o[(v + 8 | 0) >> 2]) | 0) + -51403784 | 0) | 0) << 9 | M >>> 23) + T |
															0) & w | T & (-1 ^ w)) + (0 | o[(v + 28 | 0) >> 2]) | 0) + 1735328473 | 0) |
														0) << 14 | E >>> 18) + M | 0) & T | M & (-1 ^ T)) + (0 | o[(v + 48 | 0) >> 2]) |
													0) + -1926607734 | 0) | 0) << 20 | w >>> 12) + E | 0) + ((((E = (E = (E = E + ((((M =
														(M = (M = M + ((((T = (T = (T = T + (((w ^ E ^ M) + (0 | o[(v + 20 | 0) >> 2]) |
															0) + -378558 | 0) | 0) << 4 | T >>> 28) + w | 0) ^ w ^ E) + (0 | o[(v +
															32 | 0) >> 2]) | 0) + -2022574463 | 0) | 0) << 11 | M >>> 21) + T | 0) ^ T ^
													w) + (0 | o[(v + 44 | 0) >> 2]) | 0) + 1839030562 | 0) | 0) << 16 | E >>> 16) + M |
												0) ^ M ^ T) + (0 | o[(v + 56 | 0) >> 2]) | 0) + -35309556 | 0) | 0) << 23 | w >>> 9) + E |
											0) + ((((E = (E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w ^ E ^ M) + (0 |
														o[(v + 4 | 0) >> 2]) | 0) + -1530992060 | 0) | 0) << 4 | T >>> 28) + w |
													0) ^ w ^ E) + (0 | o[(v + 16 | 0) >> 2]) | 0) + 1272893353 | 0) | 0) << 11 | M >>>
												21) + T | 0) ^ T ^ w) + (0 | o[(v + 28 | 0) >> 2]) | 0) + -155497632 | 0) | 0) << 16 |
											E >>> 16) + M | 0) ^ M ^ T) + (0 | o[(v + 40 | 0) >> 2]) | 0) + -1094730640 | 0) | 0) <<
										23 | w >>> 9) + E | 0) + ((((E = (E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (
													((w ^ E ^ M) + (0 | o[(v + 52 | 0) >> 2]) | 0) + 681279174 | 0) | 0) << 4 |
												T >>> 28) + w | 0) ^ w ^ E) + (0 | o[v >> 2]) | 0) + -358537222 | 0) | 0) << 11 |
											M >>> 21) + T | 0) ^ T ^ w) + (0 | o[(v + 12 | 0) >> 2]) | 0) + -722521979 | 0) | 0) <<
										16 | E >>> 16) + M | 0) ^ M ^ T) + (0 | o[(v + 24 | 0) >> 2]) | 0) + 76029189 | 0) | 0) << 23 |
									w >>> 9) + E | 0) + ((((E = (E = (E = E + ((((M = (M = (M = M + ((((T = (T = (T = T + (((w ^ E ^
												M) + (0 | o[(v + 36 | 0) >> 2]) | 0) + -640364487 | 0) | 0) << 4 | T >>> 28) +
											w | 0) ^ w ^ E) + (0 | o[(v + 48 | 0) >> 2]) | 0) + -421815835 | 0) | 0) << 11 | M >>>
										21) + T | 0) ^ T ^ w) + (0 | o[(v + 60 | 0) >> 2]) | 0) + 530742520 | 0) | 0) << 16 | E >>>
									16) + M | 0) ^ M ^ T) + (0 | o[(v + 8 | 0) >> 2]) | 0) + -995338651 | 0) | 0) << 23 | w >>> 9) +
								E | 0) + ((((M = (M = (M = M + (((w ^ ((T = (T = (T = T + (((E ^ (w | -1 ^ M)) + (0 | o[v >> 2]) |
										0) + -198630844 | 0) | 0) << 6 | T >>> 26) + w | 0) | -1 ^ E)) + (0 | o[(v + 28 | 0) >> 2]) |
									0) + 1126891415 | 0) | 0) << 10 | M >>> 22) + T | 0) ^ ((E = (E = (E = E + (((T ^ (M | -1 ^ w)) +
									(0 | o[(v + 56 | 0) >> 2]) | 0) + -1416354905 | 0) | 0) << 15 | E >>> 17) + M | 0) | -1 ^ T)) +
								(0 | o[(v + 20 | 0) >> 2]) | 0) + -57434055 | 0) | 0) << 21 | w >>> 11) + E | 0) + ((((M = (M = (M =
								M + (((w ^ ((T = (T = (T = T + (((E ^ (w | -1 ^ M)) + (0 | o[(v + 48 | 0) >> 2]) | 0) +
										1700485571 | 0) | 0) << 6 | T >>> 26) + w | 0) | -1 ^ E)) + (0 | o[(v + 12 | 0) >> 2]) | 0) +
									-1894986606 | 0) | 0) << 10 | M >>> 22) + T | 0) ^ ((E = (E = (E = E + (((T ^ (M | -1 ^ w)) + (0 |
								o[(v + 40 | 0) >> 2]) | 0) + -1051523 | 0) | 0) << 15 | E >>> 17) + M | 0) | -1 ^ T)) + (0 | o[(v +
								4 | 0) >> 2]) | 0) + -2054922799 | 0) | 0) << 21 | w >>> 11) + E | 0) + ((((M = (M = (M = M + (((w ^ ((T =
										(T = (T = T + (((E ^ (w | -1 ^ M)) + (0 | o[(v + 32 | 0) >> 2]) | 0) + 1873313359 | 0) | 0) <<
											6 | T >>> 26) + w | 0) | -1 ^ E)) + (0 | o[(v + 60 | 0) >> 2]) | 0) + -30611744 | 0) | 0) << 10 |
									M >>> 22) + T | 0) ^ ((E = (E = (E = E + (((T ^ (M | -1 ^ w)) + (0 | o[(v + 24 | 0) >> 2]) | 0) + -
									1560198380 | 0) | 0) << 15 | E >>> 17) + M | 0) | -1 ^ T)) + (0 | o[(v + 52 | 0) >> 2]) | 0) +
								1309151649 | 0) | 0) << 21 | w >>> 11) + E | 0) + ((((M = (M = (M = M + (((w ^ ((T = (T = (T = T + (((E ^
								(w | -1 ^ M)) + (0 | o[(v + 16 | 0) >> 2]) | 0) + -145523070 | 0) | 0) << 6 | T >>> 26) + w | 0) |
							-1 ^ E)) + (0 | o[(v + 44 | 0) >> 2]) | 0) + -1120210379 | 0) | 0) << 10 | M >>> 22) + T | 0) ^ ((E = (E =
								(E = E + (((T ^ (M | -1 ^ w)) + (0 | o[(v + 8 | 0) >> 2]) | 0) + 718787259 | 0) | 0) << 15 | E >>> 17) +
							M | 0) | -1 ^ T)) + (0 | o[(v + 36 | 0) >> 2]) | 0) + -343485551 | 0) | 0) << 21 | w >>> 11) + E | 0, r = T,
						i = (0 | o[(n = y) >> 2]) + r | 0, o[n >> 2] = i, a = w, s = (0 | o[(u = y + 4 | 0) >> 2]) + a | 0, o[u >> 2] =
						s, c = E, h = (0 | o[(d = y + 8 | 0) >> 2]) + c | 0, o[d >> 2] = h, p = M, m = (0 | o[(_ = y + 12 | 0) >> 2]) +
						p | 0, o[_ >> 2] = m, f = A
				}

				function W(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var i, a, u, s, c = 0,
						d = 0,
						h = 0;
					for (s = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), i = e, a = t, u = r, d = 0, h = 0; h >>> 0 < u >>> 0;) c =
						255 & (0 | n[(a + h | 0) >> 0]) | (255 & (0 | n[(a + (h + 1 | 0) | 0) >> 0])) << 8 | (255 & (0 | n[(a + (h + 2 |
							0) | 0) >> 0])) << 16 | (255 & (0 | n[(a + (h + 3 | 0) | 0) >> 0])) << 24, o[(i + (d << 2) | 0) >> 2] = c, d =
						d + 1 | 0, h = h + 4 | 0;
					f = s
				}

				function z(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var n, i, a, u, s, c, d;
					d = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), c = d + 24 | 0, i = t, a = r, s = ((u = 63 & (0 | o[(n = e) >>
						2]) >>> 3) >>> 0 < 56 ? 56 : 120) - u | 0, V(c, n, 8), H(n, 1271, s), H(n, c, 8), V(i, n + 8 | 0, a), f = d
				}

				function V(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var i, a, u, s, c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0;
					for (s = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), i = e, a = t, u = r, _ = 0, m = 0; m >>> 0 < u >>> 0;) c =
						255 & (255 & (0 | o[(a + (_ << 2) | 0) >> 2])), n[(i + m | 0) >> 0] = c, d = 255 & (255 & (0 | o[(a + (_ << 2) |
							0) >> 2]) >>> 8), n[(i + (m + 1 | 0) | 0) >> 0] = d, h = 255 & (255 & (0 | o[(a + (_ << 2) | 0) >> 2]) >>> 16),
						n[(i + (m + 2 | 0) | 0) >> 0] = h, p = 255 & (255 & (0 | o[(a + (_ << 2) | 0) >> 2]) >>> 24), n[(i + (m + 3 |
							0) | 0) >> 0] = p, _ = _ + 1 | 0, m = m + 4 | 0;
					f = s
				}

				function K(e) {
					e |= 0;
					var t, r = 0;
					return t = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), (0 | 255 & (r = e)) >= 97 && (0 | 255 & r) <= 122 &&
						(r = 255 & ((255 & r) - 32 | 0)), f = t, 0 | r
				}

				function X(e) {
					e |= 0;
					var t, r, n, i, a, u, s, c, d, h, p, _, m, y = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						se = 0,
						fe = 0,
						le = 0,
						ce = 0,
						de = 0,
						he = 0,
						pe = 0,
						_e = 0,
						me = 0,
						ye = 0,
						ge = 0,
						be = 0,
						ve = 0,
						Ae = 0,
						Te = 0,
						we = 0,
						Ee = 0,
						Me = 0,
						Se = 0,
						ke = 0,
						Re = 0,
						Ie = 0,
						Oe = 0,
						Be = 0,
						Ce = 0,
						Le = 0,
						Ne = 0,
						xe = 0,
						Ue = 0,
						Fe = 0,
						De = 0,
						Ye = 0,
						He = 0,
						je = 0,
						We = 0,
						ze = 0,
						Ve = 0,
						Ke = 0,
						Xe = 0,
						Ge = 0,
						Je = 0,
						$e = 0,
						qe = 0,
						Ze = 0,
						Qe = 0,
						et = 0,
						tt = 0,
						rt = 0,
						nt = 0,
						it = 0,
						ot = 0,
						at = 0,
						ut = 0,
						st = 0,
						ft = 0,
						lt = 0,
						ct = 0,
						dt = 0,
						ht = 0,
						pt = 0,
						_t = 0,
						mt = 0,
						yt = 0,
						gt = 0,
						bt = 0,
						vt = 0,
						At = 0,
						Tt = 0,
						wt = 0,
						Et = 0,
						Mt = 0,
						St = 0,
						kt = 0,
						Rt = 0,
						It = 0,
						Ot = 0,
						Pt = 0,
						Bt = 0,
						Ct = 0,
						Lt = 0,
						Nt = 0,
						xt = 0,
						Ut = 0,
						Ft = 0,
						Dt = 0,
						Yt = 0,
						Ht = 0,
						jt = 0,
						Wt = 0,
						zt = 0,
						Vt = 0,
						Kt = 0,
						Xt = 0,
						Gt = 0,
						Jt = 0,
						$t = 0,
						qt = 0,
						Zt = 0,
						Qt = 0,
						er = 0,
						tr = 0,
						rr = 0,
						nr = 0,
						ir = 0,
						or = 0,
						ar = 0,
						ur = 0,
						sr = 0,
						fr = 0,
						lr = 0,
						cr = 0,
						dr = 0,
						hr = 0,
						pr = 0,
						_r = 0,
						mr = 0,
						yr = 0,
						gr = 0,
						br = 0,
						vr = 0,
						Ar = 0,
						Tr = 0,
						wr = 0,
						Er = 0,
						Mr = 0,
						Sr = 0,
						kr = 0,
						Rr = 0,
						Ir = 0,
						Or = 0,
						Pr = 0,
						Br = 0,
						Cr = 0,
						Lr = 0,
						Nr = 0,
						xr = 0,
						Ur = 0,
						Fr = 0,
						Dr = 0,
						Yr = 0,
						Hr = 0,
						jr = 0,
						Wr = 0,
						zr = 0,
						Vr = 0,
						Kr = 0,
						Xr = 0,
						Gr = 0,
						Jr = 0,
						$r = 0,
						qr = 0,
						Zr = 0,
						Qr = 0,
						en = 0,
						tn = 0,
						rn = 0,
						nn = 0,
						on = 0,
						an = 0,
						un = 0,
						sn = 0,
						fn = 0,
						ln = 0,
						cn = 0,
						dn = 0,
						hn = 0,
						pn = 0,
						_n = 0,
						mn = 0,
						yn = 0,
						gn = 0,
						bn = 0,
						vn = 0,
						An = 0,
						Tn = 0,
						wn = 0,
						En = 0,
						Mn = 0,
						Sn = 0,
						kn = 0,
						Rn = 0,
						In = 0,
						On = 0,
						Pn = 0,
						Bn = 0,
						Cn = 0,
						Ln = 0,
						Nn = 0,
						xn = 0,
						Un = 0,
						Fn = 0,
						Dn = 0,
						Yn = 0,
						Hn = 0,
						jn = 0,
						Wn = 0,
						zn = 0,
						Vn = 0,
						Kn = 0,
						Xn = 0,
						Gn = 0,
						Jn = 0,
						$n = 0,
						qn = 0,
						Zn = 0,
						Qn = 0,
						ei = 0,
						ti = 0,
						ri = 0,
						ni = 0,
						ii = 0,
						oi = 0,
						ai = 0,
						ui = 0,
						si = 0,
						fi = 0,
						li = 0,
						ci = 0,
						di = 0,
						hi = 0,
						pi = 0,
						_i = 0,
						mi = 0,
						yi = 0,
						gi = 0,
						bi = 0,
						vi = 0,
						Ai = 0,
						Ti = 0,
						wi = 0,
						Ei = 0,
						Mi = 0,
						Si = 0,
						ki = 0,
						Ri = 0,
						Ii = 0,
						Oi = 0,
						Pi = 0,
						Bi = 0,
						Ci = 0,
						Li = 0,
						Ni = 0,
						xi = 0,
						Ui = 0,
						Fi = 0,
						Di = 0,
						Yi = 0,
						Hi = 0,
						ji = 0,
						Wi = 0,
						zi = 0,
						Vi = 0,
						Ki = 0,
						Xi = 0,
						Gi = 0,
						Ji = 0,
						$i = 0,
						qi = 0,
						Zi = 0,
						Qi = 0,
						eo = 0,
						to = 0,
						ro = 0,
						no = 0,
						io = 0,
						oo = 0,
						ao = 0,
						uo = 0,
						so = 0,
						fo = 0,
						lo = 0,
						co = 0,
						ho = 0,
						po = 0,
						_o = 0,
						mo = 0,
						yo = 0,
						go = 0,
						bo = 0,
						vo = 0,
						Ao = 0,
						To = 0,
						wo = 0,
						Eo = 0,
						Mo = 0,
						So = 0,
						ko = 0,
						Ro = 0,
						Io = 0,
						Oo = 0,
						Po = 0,
						Bo = 0,
						Co = 0,
						Lo = 0,
						No = 0,
						xo = 0,
						Uo = 0,
						Fo = 0,
						Do = 0,
						Yo = 0,
						Ho = 0,
						jo = 0,
						Wo = 0,
						zo = 0,
						Vo = 0,
						Ko = 0,
						Xo = 0,
						Go = 0,
						Jo = 0,
						$o = 0,
						qo = 0,
						Zo = 0,
						Qo = 0,
						ea = 0,
						ta = 0,
						ra = 0,
						na = 0,
						ia = 0,
						oa = 0,
						aa = 0,
						ua = 0,
						sa = 0,
						fa = 0,
						la = 0,
						ca = 0,
						da = 0,
						ha = 0,
						pa = 0,
						_a = 0,
						ma = 0,
						ya = 0,
						ga = 0,
						ba = 0,
						va = 0,
						Aa = 0,
						Ta = 0,
						wa = 0,
						Ea = 0,
						Ma = 0,
						Sa = 0,
						ka = 0,
						Ra = 0,
						Ia = 0,
						Oa = 0,
						Pa = 0,
						Ba = 0,
						Ca = 0,
						La = 0,
						Na = 0,
						xa = 0,
						Ua = 0,
						Fa = 0,
						Da = 0,
						Ya = 0,
						Ha = 0,
						ja = 0,
						Wa = 0,
						za = 0,
						Va = 0,
						Ka = 0,
						Xa = 0,
						Ga = 0,
						Ja = 0,
						$a = 0,
						qa = 0,
						Za = 0,
						Qa = 0,
						eu = 0,
						tu = 0,
						ru = 0,
						nu = 0,
						iu = 0,
						ou = 0,
						au = 0,
						uu = 0,
						su = 0,
						fu = 0,
						lu = 0,
						cu = 0,
						du = 0,
						hu = 0,
						pu = 0,
						_u = 0,
						mu = 0,
						yu = 0,
						gu = 0,
						bu = 0,
						vu = 0,
						Au = 0,
						Tu = 0,
						wu = 0,
						Eu = 0,
						Mu = 0,
						Su = 0,
						ku = 0;
					m = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), t = m, r = e >>> 0 < 245;
					do {
						if (r) {
							if (vo = (Ri = e >>> 0 < 11 ? 16 : -8 & (e + 11 | 0)) >>> 3, !(0 == (0 | 3 & (tu = (da = 0 | o[1021]) >>> vo))))
								return wt = 0 | o[(gt = (ct = 4124 + ((et = (1 ^ 1 & tu) + vo | 0) << 1 << 2) | 0) + 8 | 0) >> 2], (0 | ct) ==
									(0 | (Pt = 0 | o[(St = wt + 8 | 0) >> 2])) ? (Jt = da & (-1 ^ 1 << et), o[1021] = Jt) : (o[(Pt + 12 | 0) >>
										2] = ct, o[gt >> 2] = Pt), ir = 3 | (er = et << 3), o[(wt + 4 | 0) >> 2] = ir, wr = 1 | (0 | o[(yr = (wt +
										er | 0) + 4 | 0) >> 2]), o[yr >> 2] = wr, f = m, 0 | St;
							if (Ri >>> 0 > (Ir = 0 | o[1023]) >>> 0) {
								if (!(0 == (0 | tu))) return ro = 0 | o[(Zi = (Gi = 4124 + ((Hi = ((Fn = 8 & (kn = (bn = ((un = tu << vo & (
										(Xr = 2 << vo) | (0 - Xr | 0))) & (0 - un | 0)) + -1 | 0) >>> (wn = 16 & bn >>> 12)) >>> 5) | wn |
									(Qn = 4 & (zn = kn >>> Fn) >>> 2) | (di = 2 & (ai = zn >>> Qn) >>> 1) | (Ii = 1 & (bi = ai >>> di) >>>
										1)) + (bi >>> Ii) | 0) << 1 << 2) | 0) + 8 | 0) >> 2], (0 | Gi) == (0 | (po = 0 | o[(fo = ro + 8 | 0) >>
									2])) ? (xo = da & (-1 ^ 1 << Hi), o[1021] = xo, ru = xo) : (o[(po + 12 | 0) >> 2] = Gi, o[Zi >> 2] = po,
									ru = da), Go = (Hi << 3) - Ri | 0, ta = 3 | Ri, o[(ro + 4 | 0) >> 2] = ta, ha = 1 | Go, o[((fa = ro + Ri |
									0) + 4 | 0) >> 2] = ha, o[(fa + Go | 0) >> 2] = Go, 0 == (0 | Ir) || (Ma = 0 | o[1026], Da = 4124 + ((Ra =
									Ir >>> 3) << 1 << 2) | 0, 0 == (0 | ru & (za = 1 << Ra)) ? (fu = ru | za, o[1021] = fu, B = Da, xe = Da +
									8 | 0) : (B = 0 | o[(hu = Da + 8 | 0) >> 2], xe = hu), o[xe >> 2] = Ma, o[(B + 12 | 0) >> 2] = Ma, o[(Ma +
									8 | 0) >> 2] = B, o[(Ma + 12 | 0) >> 2] = Da), o[1023] = Go, o[1026] = fa, f = m, 0 | fo;
								if (0 == (0 | (Su = 0 | o[1022]))) P = Ri;
								else {
									if (Xe = 0 | o[(4388 + ((((Ye = 8 & (De = (Ue = (Su & (0 - Su | 0)) + -1 | 0) >>> (Fe = 16 & Ue >>> 12)) >>>
											5) | Fe | (je = 4 & (He = De >>> Ye) >>> 2) | (ze = 2 & (We = He >>> je) >>> 1) | (Ke = 1 & (Ve = We >>>
											ze) >>> 1)) + (Ve >>> Ke) | 0) << 2) | 0) >> 2], Ge = (-8 & (0 | o[(Xe + 4 | 0) >> 2])) - Ri | 0, Je = 0 |
										o[(Xe + 16 | 0) >> 2], 0 == (0 | ($e = 0 | o[((Xe + 16 | 0) + ((1 & 0 == (0 | Je)) << 2) | 0) >> 2]))) k =
										Xe, I = Ge;
									else
										for (R = Xe, O = Ge, qe = $e;;) {
											if (b = (Qe = (Ze = (-8 & (0 | o[(qe + 4 | 0) >> 2])) - Ri | 0) >>> 0 < O >>> 0) ? Ze : O, y = Qe ? qe :
												R, tt = 0 | o[(qe + 16 | 0) >> 2], 0 == (0 | (rt = 0 | o[((qe + 16 | 0) + ((1 & 0 == (0 | tt)) << 2) | 0) >>
													2]))) {
												k = y, I = b;
												break
											}
											R = y, O = b, qe = rt
										}
									if (k >>> 0 < (nt = k + Ri | 0) >>> 0) {
										it = 0 | o[(k + 24 | 0) >> 2], at = (0 | (ot = 0 | o[(k + 12 | 0) >> 2])) == (0 | k);
										do {
											if (at) {
												if (0 == (0 | (ft = 0 | o[(st = k + 20 | 0) >> 2]))) {
													if (0 == (0 | (dt = 0 | o[(lt = k + 16 | 0) >> 2]))) {
														_e = 0;
														break
													}
													te = dt, re = lt
												} else te = ft, re = st;
												for (;;)
													if (0 == (0 | (pt = 0 | o[(ht = te + 20 | 0) >> 2]))) {
														if (0 == (0 | (mt = 0 | o[(_t = te + 16 | 0) >> 2]))) break;
														te = mt, re = _t
													} else te = pt, re = ht;
												o[re >> 2] = 0, _e = te
											} else ut = 0 | o[(k + 8 | 0) >> 2], o[(ut + 12 | 0) >> 2] = ot, o[(ot + 8 | 0) >> 2] = ut, _e = ot
										} while (0);
										yt = 0 == (0 | it);
										do {
											if (!yt) {
												if (bt = 0 | o[(k + 28 | 0) >> 2], (0 | k) == (0 | (0 | o[(vt = 4388 + (bt << 2) | 0) >> 2]))) {
													if (o[vt >> 2] = _e, 0 == (0 | _e)) {
														At = Su & (-1 ^ 1 << bt), o[1022] = At;
														break
													}
												} else if (Tt = 0 | o[(it + 16 | 0) >> 2], o[((it + 16 | 0) + ((1 & (0 | Tt) != (0 | k)) << 2) | 0) >> 2] =
													_e, 0 == (0 | _e)) break;
												o[(_e + 24 | 0) >> 2] = it, 0 == (0 | (Et = 0 | o[(k + 16 | 0) >> 2])) || (o[(_e + 16 | 0) >> 2] = Et, o[
													(Et + 24 | 0) >> 2] = _e), 0 == (0 | (Mt = 0 | o[(k + 20 | 0) >> 2])) || (o[(_e + 20 | 0) >> 2] = Mt,
													o[(Mt + 24 | 0) >> 2] = _e)
											}
										} while (0);
										return I >>> 0 < 16 ? (Rt = 3 | (kt = I + Ri | 0), o[(k + 4 | 0) >> 2] = Rt, Ot = 1 | (0 | o[(It = (k + kt |
											0) + 4 | 0) >> 2]), o[It >> 2] = Ot) : (Bt = 3 | Ri, o[(k + 4 | 0) >> 2] = Bt, Ct = 1 | I, o[(nt + 4 | 0) >>
											2] = Ct, o[(nt + I | 0) >> 2] = I, 0 == (0 | Ir) || (Lt = 0 | o[1026], xt = 4124 + ((Nt = Ir >>> 3) <<
												1 << 2) | 0, 0 == (0 | da & (Ut = 1 << Nt)) ? (Ft = da | Ut, o[1021] = Ft, T = xt, Ne = xt + 8 | 0) :
											(T = 0 | o[(Dt = xt + 8 | 0) >> 2], Ne = Dt), o[Ne >> 2] = Lt, o[(T + 12 | 0) >> 2] = Lt, o[(Lt + 8 | 0) >>
												2] = T, o[(Lt + 12 | 0) >> 2] = xt), o[1023] = I, o[1026] = nt), f = m, 0 | (k + 8 | 0)
									}
									P = Ri
								}
							} else P = Ri
						} else if (e >>> 0 > 4294967231) P = -1;
						else if (Ht = -8 & (Yt = e + 11 | 0), 0 == (0 | (jt = 0 | o[1022]))) P = Ht;
						else {
							Wt = 0 - Ht | 0, G = 0 == (0 | (zt = Yt >>> 8)) ? 0 : Ht >>> 0 > 16777215 ? 31 : 1 & Ht >>> ((qt = (14 - ((Xt =
								4 & ((Kt = zt << (Vt = 8 & (zt + 1048320 | 0) >>> 16)) + 520192 | 0) >>> 16) | Vt | ($t = 2 & ((Gt = Kt <<
								Xt) + 245760 | 0) >>> 16)) | 0) + (Gt << $t >>> 15) | 0) + 7 | 0) | qt << 1, Qt = 0 == (0 | (Zt = 0 | o[(
								4388 + (G << 2) | 0) >> 2]));
							e: do {
								if (Qt) pe = 0, ye = 0, ge = Wt, ku = 57;
								else
									for (W = 0, K = Wt, X = Zt, $ = Ht << (31 == (0 | G) ? 0 : 25 - (G >>> 1) | 0), Q = 0;;) {
										if ((tr = (-8 & (0 | o[(X + 4 | 0) >> 2])) - Ht | 0) >>> 0 < K >>> 0) {
											if (0 == (0 | tr)) {
												Te = X, Me = 0, Re = X, ku = 61;
												break e
											}
											ae = X, ue = tr
										} else ae = W, ue = K;
										if (se = 0 == (0 | (rr = 0 | o[(X + 20 | 0) >> 2])) | (0 | rr) == (0 | (nr = 0 | o[((X + 16 | 0) + ($ >>>
												31 << 2) | 0) >> 2])) ? Q : rr, J = $ << (1 & (1 ^ (or = 0 == (0 | nr)))), or) {
											pe = se, ye = ae, ge = ue, ku = 57;
											break
										}
										W = ae, K = ue, X = nr, $ = J, Q = se
									}
							} while (0);
							if (57 == (0 | ku)) {
								if (0 == (0 | pe) & 0 == (0 | ye)) {
									if (0 == (0 | (ur = jt & ((ar = 2 << G) | (0 - ar | 0))))) {
										P = Ht;
										break
									}
									Ae = 0, ke = 0 | o[(4388 + ((((cr = 8 & (lr = (sr = (ur & (0 - ur | 0)) + -1 | 0) >>> (fr = 16 & sr >>> 12)) >>>
										5) | fr | (hr = 4 & (dr = lr >>> cr) >>> 2) | (_r = 2 & (pr = dr >>> hr) >>> 1) | (gr = 1 & (mr = pr >>>
										_r) >>> 1)) + (mr >>> gr) | 0) << 2) | 0) >> 2]
								} else Ae = ye, ke = pe;
								0 == (0 | ke) ? (ve = Ae, Ee = ge) : (Te = Ae, Me = ge, Re = ke, ku = 61)
							}
							if (61 == (0 | ku))
								for (;;) {
									if (ku = 0, v = (vr = (br = (-8 & (0 | o[(Re + 4 | 0) >> 2])) - Ht | 0) >>> 0 < Me >>> 0) ? br : Me, Se =
										vr ? Re : Te, Ar = 0 | o[(Re + 16 | 0) >> 2], 0 == (0 | (Tr = 0 | o[((Re + 16 | 0) + ((1 & 0 == (0 | Ar)) <<
											2) | 0) >> 2]))) {
										ve = Se, Ee = v;
										break
									}
									Te = Se, Me = v, Re = Tr, ku = 61
								}
							if (0 == (0 | ve)) P = Ht;
							else {
								if (Ee >>> 0 < ((0 | o[1023]) - Ht | 0) >>> 0) {
									if (!(ve >>> 0 < (Er = ve + Ht | 0) >>> 0)) return f = m, 0 | 0;
									Mr = 0 | o[(ve + 24 | 0) >> 2], kr = (0 | (Sr = 0 | o[(ve + 12 | 0) >> 2])) == (0 | ve);
									do {
										if (kr) {
											if (0 == (0 | (Pr = 0 | o[(Or = ve + 20 | 0) >> 2]))) {
												if (0 == (0 | (Cr = 0 | o[(Br = ve + 16 | 0) >> 2]))) {
													be = 0;
													break
												}
												fe = Cr, le = Br
											} else fe = Pr, le = Or;
											for (;;)
												if (0 == (0 | (Nr = 0 | o[(Lr = fe + 20 | 0) >> 2]))) {
													if (0 == (0 | (Ur = 0 | o[(xr = fe + 16 | 0) >> 2]))) break;
													fe = Ur, le = xr
												} else fe = Nr, le = Lr;
											o[le >> 2] = 0, be = fe
										} else Rr = 0 | o[(ve + 8 | 0) >> 2], o[(Rr + 12 | 0) >> 2] = Sr, o[(Sr + 8 | 0) >> 2] = Rr, be = Sr
									} while (0);
									Fr = 0 == (0 | Mr);
									do {
										if (Fr) yn = jt;
										else {
											if (Dr = 0 | o[(ve + 28 | 0) >> 2], (0 | ve) == (0 | (0 | o[(Yr = 4388 + (Dr << 2) | 0) >> 2]))) {
												if (o[Yr >> 2] = be, 0 == (0 | be)) {
													Hr = jt & (-1 ^ 1 << Dr), o[1022] = Hr, yn = Hr;
													break
												}
											} else if (jr = 0 | o[(Mr + 16 | 0) >> 2], o[((Mr + 16 | 0) + ((1 & (0 | jr) != (0 | ve)) << 2) | 0) >> 2] =
												be, 0 == (0 | be)) {
												yn = jt;
												break
											}
											o[(be + 24 | 0) >> 2] = Mr, 0 == (0 | (Wr = 0 | o[(ve + 16 | 0) >> 2])) || (o[(be + 16 | 0) >> 2] = Wr, o[
												(Wr + 24 | 0) >> 2] = be), 0 == (0 | (zr = 0 | o[(ve + 20 | 0) >> 2])) ? yn = jt : (o[(be + 20 | 0) >>
												2] = zr, o[(zr + 24 | 0) >> 2] = be, yn = jt)
										}
									} while (0);
									Vr = Ee >>> 0 < 16;
									do {
										if (Vr) Gr = 3 | (Kr = Ee + Ht | 0), o[(ve + 4 | 0) >> 2] = Gr, $r = 1 | (0 | o[(Jr = (ve + Kr | 0) + 4 |
											0) >> 2]), o[Jr >> 2] = $r;
										else {
											if (qr = 3 | Ht, o[(ve + 4 | 0) >> 2] = qr, Zr = 1 | Ee, o[(Er + 4 | 0) >> 2] = Zr, o[(Er + Ee | 0) >> 2] =
												Ee, Qr = Ee >>> 3, Ee >>> 0 < 256) {
												en = 4124 + (Qr << 1 << 2) | 0, 0 == (0 | (tn = 0 | o[1021]) & (rn = 1 << Qr)) ? (nn = tn | rn, o[1021] =
													nn, ee = en, Le = en + 8 | 0) : (ee = 0 | o[(on = en + 8 | 0) >> 2], Le = on), o[Le >> 2] = Er, o[(ee +
													12 | 0) >> 2] = Er, o[(Er + 8 | 0) >> 2] = ee, o[(Er + 12 | 0) >> 2] = en;
												break
											}
											if (pn = 4388 + ((Z = 0 == (0 | (an = Ee >>> 8)) ? 0 : Ee >>> 0 > 16777215 ? 31 : 1 & Ee >>> ((hn = (14 -
													((ln = 4 & ((fn = an << (sn = 8 & (an + 1048320 | 0) >>> 16)) + 520192 | 0) >>> 16) | sn | (dn = 2 &
														((cn = fn << ln) + 245760 | 0) >>> 16)) | 0) + (cn << dn >>> 15) | 0) + 7 | 0) | hn << 1) << 2) | 0, o[
													(Er + 28 | 0) >> 2] = Z, o[((_n = Er + 16 | 0) + 4 | 0) >> 2] = 0, o[_n >> 2] = 0, 0 == (0 | yn & (mn =
													1 << Z))) {
												gn = yn | mn, o[1022] = gn, o[pn >> 2] = Er, o[(Er + 24 | 0) >> 2] = pn, o[(Er + 12 | 0) >> 2] = Er, o[(
													Er + 8 | 0) >> 2] = Er;
												break
											}
											for (z = Ee << (31 == (0 | Z) ? 0 : 25 - (Z >>> 1) | 0), V = 0 | o[pn >> 2];;) {
												if ((0 | -8 & (0 | o[(V + 4 | 0) >> 2])) == (0 | Ee)) {
													ku = 97;
													break
												}
												if (An = z << 1, 0 == (0 | (Tn = 0 | o[(vn = (V + 16 | 0) + (z >>> 31 << 2) | 0) >> 2]))) {
													ku = 96;
													break
												}
												z = An, V = Tn
											}
											if (96 == (0 | ku)) {
												o[vn >> 2] = Er, o[(Er + 24 | 0) >> 2] = V, o[(Er + 12 | 0) >> 2] = Er, o[(Er + 8 | 0) >> 2] = Er;
												break
											}
											if (97 == (0 | ku)) {
												Mn = 0 | o[(En = V + 8 | 0) >> 2], o[(Mn + 12 | 0) >> 2] = Er, o[En >> 2] = Er, o[(Er + 8 | 0) >> 2] =
													Mn, o[(Er + 12 | 0) >> 2] = V, o[(Er + 24 | 0) >> 2] = 0;
												break
											}
										}
									} while (0);
									return f = m, 0 | (ve + 8 | 0)
								}
								P = Ht
							}
						}
					} while (0);
					if (!((n = 0 | o[1023]) >>> 0 < P >>> 0)) return Sn = n - P | 0, Rn = 0 | o[1026], Sn >>> 0 > 15 ? (In = Rn + P |
						0, o[1026] = In, o[1023] = Sn, On = 1 | Sn, o[(In + 4 | 0) >> 2] = On, o[(In + Sn | 0) >> 2] = Sn, Pn = 3 |
						P, o[(Rn + 4 | 0) >> 2] = Pn) : (o[1023] = 0, o[1026] = 0, Bn = 3 | n, o[(Rn + 4 | 0) >> 2] = Bn, Ln = 1 | (
						0 | o[(Cn = (Rn + n | 0) + 4 | 0) >> 2]), o[Cn >> 2] = Ln), f = m, 0 | (Rn + 8 | 0);
					if ((i = 0 | o[1024]) >>> 0 > P >>> 0) return Nn = i - P | 0, o[1024] = Nn, Un = (xn = 0 | o[1027]) + P | 0, o[
						1027] = Un, Dn = 1 | Nn, o[(Un + 4 | 0) >> 2] = Dn, Yn = 3 | P, o[(xn + 4 | 0) >> 2] = Yn, f = m, 0 | (xn +
						8 | 0);
					if (0 == (0 | (0 | o[1139])) ? (o[1141] = 4096, o[1140] = 4096, o[1142] = -1, o[1143] = -1, o[1144] = 0, o[1132] =
							0, Hn = 1431655768 ^ -16 & t, o[t >> 2] = Hn, o[1139] = Hn, jn = 4096) : jn = 0 | o[1141], a = P + 48 | 0, !(
							(d = (s = jn + (u = P + 47 | 0) | 0) & (c = 0 - jn | 0)) >>> 0 > P >>> 0)) return f = m, 0 | 0;
					if (!(0 == (0 | (h = 0 | o[1131]))) && (Vn = (Wn = 0 | o[1129]) + d | 0) >>> 0 <= Wn >>> 0 | Vn >>> 0 > h >>>
						0) return f = m, 0 | 0;
					p = 0 == (0 | 4 & (0 | o[1132]));
					e: do {
						if (p) {
							Xn = 0 == (0 | (Kn = 0 | o[1027]));
							t: do {
								if (Xn) ku = 118;
								else {
									for (M = 4532;
										(Gn = 0 | o[M >> 2]) >>> 0 > Kn >>> 0 || !((Gn + (0 | o[(Jn = M + 4 | 0) >> 2]) | 0) >>> 0 > Kn >>> 0);) {
										if (0 == (0 | ($n = 0 | o[(M + 8 | 0) >> 2]))) {
											ku = 118;
											break t
										}
										M = $n
									}
									if ((ui = (s - i | 0) & c) >>> 0 < 2147483647)
										if ((0 | (si = 0 | Pe(0 | ui))) == (0 | ((0 | o[M >> 2]) + (0 | o[Jn >> 2]) | 0))) {
											if (!(-1 == (0 | si))) {
												Ie = ui, Oe = si, ku = 135;
												break e
											}
											ce = ui
										} else de = si, he = ui, ku = 126;
									else ce = 0
								}
							} while (0);
							do {
								if (118 == (0 | ku))
									if (-1 == (0 | (qn = 0 | Pe(0)))) ce = 0;
									else if (Zn = qn, ni = (A = (0 == (0 | (ti = (ei = 0 | o[1140]) + -1 | 0) & Zn) ? 0 : ((ti + Zn | 0) & (0 -
										ei | 0)) - Zn | 0) + d | 0) + (ri = 0 | o[1129]) | 0, A >>> 0 > P >>> 0 & A >>> 0 < 2147483647) {
									if (!(0 == (0 | (ii = 0 | o[1131]))) && ni >>> 0 <= ri >>> 0 | ni >>> 0 > ii >>> 0) {
										ce = 0;
										break
									}
									if ((0 | (oi = 0 | Pe(0 | A))) == (0 | qn)) {
										Ie = A, Oe = qn, ku = 135;
										break e
									}
									de = oi, he = A, ku = 126
								} else ce = 0
							} while (0);
							do {
								if (126 == (0 | ku)) {
									if (fi = 0 - he | 0, !(a >>> 0 > he >>> 0 & (he >>> 0 < 2147483647 & -1 != (0 | de)))) {
										if (-1 == (0 | de)) {
											ce = 0;
											break
										}
										Ie = he, Oe = de, ku = 135;
										break e
									}
									if (!((ci = ((u - he | 0) + (li = 0 | o[1141]) | 0) & (0 - li | 0)) >>> 0 < 2147483647)) {
										Ie = he, Oe = de, ku = 135;
										break e
									}
									if (-1 == (0 | (0 | Pe(0 | ci)))) {
										Pe(0 | fi), ce = 0;
										break
									}
									Ie = ci + he | 0, Oe = de, ku = 135;
									break e
								}
							} while (0);
							hi = 4 | (0 | o[1132]), o[1132] = hi, we = ce, ku = 133
						} else we = 0, ku = 133
					} while (0);
					if (133 == (0 | ku) && d >>> 0 < 2147483647 && (-1 == (0 | (pi = 0 | Pe(0 | d))) | 1 ^ (yi = (mi = (_i = 0 | Pe(
							0)) - pi | 0) >>> 0 > (P + 40 | 0) >>> 0) | 1 ^ pi >>> 0 < _i >>> 0 & (-1 != (0 | pi) & -1 != (0 | _i)) || (
							Ie = yi ? mi : we, Oe = pi, ku = 135)), 135 == (0 | ku)) {
						gi = (0 | o[1129]) + Ie | 0, o[1129] = gi, gi >>> 0 > (0 | o[1130]) >>> 0 && (o[1130] = gi), Ai = 0 == (0 | (
							vi = 0 | o[1027]));
						do {
							if (Ai) {
								for (0 == (0 | (Ti = 0 | o[1025])) | Oe >>> 0 < Ti >>> 0 && (o[1025] = Oe), o[1133] = Oe, o[1134] = Ie, o[
										1136] = 0, wi = 0 | o[1139], o[1030] = wi, o[1029] = -1, S = 0; o[((Ei = 4124 + (S << 1 << 2) | 0) + 12 |
										0) >> 2] = Ei, o[(Ei + 8 | 0) >> 2] = Ei, !(32 == (0 | (Mi = S + 1 | 0)));) S = Mi;
								Oi = Oe + (ki = 0 == (0 | 7 & (Si = Oe + 8 | 0)) ? 0 : 7 & (0 - Si | 0)) | 0, Pi = (Ie + -40 | 0) - ki | 0,
									o[1027] = Oi, o[1024] = Pi, Bi = 1 | Pi, o[(Oi + 4 | 0) >> 2] = Bi, o[((Oi + Pi | 0) + 4 | 0) >> 2] = 40,
									Ci = 0 | o[1143], o[1028] = Ci
							} else {
								for (U = 4532;;) {
									if ((0 | Oe) == (0 | ((Li = 0 | o[U >> 2]) + (xi = 0 | o[(Ni = U + 4 | 0) >> 2]) | 0))) {
										ku = 145;
										break
									}
									if (0 == (0 | (Ui = 0 | o[(U + 8 | 0) >> 2]))) break;
									U = Ui
								}
								if (145 == (0 | ku) && 0 == (0 | 8 & (0 | o[(U + 12 | 0) >> 2])) && vi >>> 0 < Oe >>> 0 & vi >>> 0 >= Li >>>
									0) {
									Fi = xi + Ie | 0, o[Ni >> 2] = Fi, ji = vi + (Yi = 0 == (0 | 7 & (Di = vi + 8 | 0)) ? 0 : 7 & (0 - Di | 0)) |
										0, Wi = (0 | o[1024]) + (Ie - Yi | 0) | 0, o[1027] = ji, o[1024] = Wi, zi = 1 | Wi, o[(ji + 4 | 0) >> 2] =
										zi, o[((ji + Wi | 0) + 4 | 0) >> 2] = 40, Vi = 0 | o[1143], o[1028] = Vi;
									break
								}
								for (Oe >>> 0 < (0 | o[1025]) >>> 0 && (o[1025] = Oe), Ki = Oe + Ie | 0, ne = 4532;;) {
									if ((0 | (0 | o[ne >> 2])) == (0 | Ki)) {
										ku = 153;
										break
									}
									if (0 == (0 | (Xi = 0 | o[(ne + 8 | 0) >> 2]))) break;
									ne = Xi
								}
								if (153 == (0 | ku) && 0 == (0 | 8 & (0 | o[(ne + 12 | 0) >> 2]))) {
									o[ne >> 2] = Oe, $i = (0 | o[(Ji = ne + 4 | 0) >> 2]) + Ie | 0, o[Ji >> 2] = $i, no = (Qi = Oe + (0 == (0 |
											7 & (qi = Oe + 8 | 0)) ? 0 : 7 & (0 - qi | 0)) | 0) + P | 0, io = ((to = Ki + (0 == (0 | 7 & (eo = Ki + 8 |
											0)) ? 0 : 7 & (0 - eo | 0)) | 0) - Qi | 0) - P | 0, oo = 3 | P, o[(Qi + 4 | 0) >> 2] = oo, ao = (0 | to) ==
										(0 | vi);
									do {
										if (ao) uo = (0 | o[1024]) + io | 0, o[1024] = uo, o[1027] = no, so = 1 | uo, o[(no + 4 | 0) >> 2] = so;
										else {
											if ((0 | to) == (0 | (0 | o[1026]))) {
												lo = (0 | o[1023]) + io | 0, o[1023] = lo, o[1026] = no, co = 1 | lo, o[(no + 4 | 0) >> 2] = co, o[(no +
													lo | 0) >> 2] = lo;
												break
											}
											if (1 == (0 | 3 & (ho = 0 | o[(to + 4 | 0) >> 2]))) {
												_o = -8 & ho, mo = ho >>> 3, yo = ho >>> 0 < 256;
												e: do {
													if (yo) {
														if (go = 0 | o[(to + 8 | 0) >> 2], (0 | (bo = 0 | o[(to + 12 | 0) >> 2])) == (0 | go)) {
															Ao = -1 ^ 1 << mo, To = (0 | o[1021]) & Ao, o[1021] = To;
															break
														}
														o[(go + 12 | 0) >> 2] = bo, o[(bo + 8 | 0) >> 2] = go;
														break
													}
													wo = 0 | o[(to + 24 | 0) >> 2], Mo = (0 | (Eo = 0 | o[(to + 12 | 0) >> 2])) == (0 | to);
													do {
														if (Mo) {
															if (0 == (0 | (Io = 0 | o[(Ro = (ko = to + 16 | 0) + 4 | 0) >> 2]))) {
																if (0 == (0 | (Oo = 0 | o[ko >> 2]))) {
																	me = 0;
																	break
																}
																ie = Oo, oe = ko
															} else ie = Io, oe = Ro;
															for (;;)
																if (0 == (0 | (Bo = 0 | o[(Po = ie + 20 | 0) >> 2]))) {
																	if (0 == (0 | (Lo = 0 | o[(Co = ie + 16 | 0) >> 2]))) break;
																	ie = Lo, oe = Co
																} else ie = Bo, oe = Po;
															o[oe >> 2] = 0, me = ie
														} else So = 0 | o[(to + 8 | 0) >> 2], o[(So + 12 | 0) >> 2] = Eo, o[(Eo + 8 | 0) >> 2] = So, me = Eo
													} while (0);
													if (0 == (0 | wo)) break;
													No = 0 | o[(to + 28 | 0) >> 2], Fo = (0 | to) == (0 | (0 | o[(Uo = 4388 + (No << 2) | 0) >> 2]));
													do {
														if (Fo) {
															if (o[Uo >> 2] = me, !(0 == (0 | me))) break;
															Do = -1 ^ 1 << No, Yo = (0 | o[1022]) & Do, o[1022] = Yo;
															break e
														}
														if (Ho = 0 | o[(wo + 16 | 0) >> 2], o[((wo + 16 | 0) + ((1 & (0 | Ho) != (0 | to)) << 2) | 0) >> 2] =
															me, 0 == (0 | me)) break e
													} while (0);
													if (o[(me + 24 | 0) >> 2] = wo, 0 == (0 | (Wo = 0 | o[(jo = to + 16 | 0) >> 2])) || (o[(me + 16 | 0) >>
															2] = Wo, o[(Wo + 24 | 0) >> 2] = me), 0 == (0 | (zo = 0 | o[(jo + 4 | 0) >> 2]))) break;
													o[(me + 20 | 0) >> 2] = zo, o[(zo + 24 | 0) >> 2] = me
												} while (0);
												w = to + _o | 0, F = _o + io | 0
											} else w = to, F = io;
											if (Ko = -2 & (0 | o[(Vo = w + 4 | 0) >> 2]), o[Vo >> 2] = Ko, Xo = 1 | F, o[(no + 4 | 0) >> 2] = Xo, o[(
													no + F | 0) >> 2] = F, Jo = F >>> 3, F >>> 0 < 256) {
												$o = 4124 + (Jo << 1 << 2) | 0, 0 == (0 | (qo = 0 | o[1021]) & (Zo = 1 << Jo)) ? (Qo = qo | Zo, o[1021] =
													Qo, H = $o, Ce = $o + 8 | 0) : (H = 0 | o[(ea = $o + 8 | 0) >> 2], Ce = ea), o[Ce >> 2] = no, o[(H +
													12 | 0) >> 2] = no, o[(no + 8 | 0) >> 2] = H, o[(no + 12 | 0) >> 2] = $o;
												break
											}
											na = 0 == (0 | (ra = F >>> 8));
											do {
												if (na) j = 0;
												else {
													if (F >>> 0 > 16777215) {
														j = 31;
														break
													}
													j = 1 & F >>> ((la = (14 - ((aa = 4 & ((oa = ra << (ia = 8 & (ra + 1048320 | 0) >>> 16)) + 520192 | 0) >>>
															16) | ia | (sa = 2 & ((ua = oa << aa) + 245760 | 0) >>> 16)) | 0) + (ua << sa >>> 15) | 0) + 7 | 0) |
														la << 1
												}
											} while (0);
											if (ca = 4388 + (j << 2) | 0, o[(no + 28 | 0) >> 2] = j, o[((pa = no + 16 | 0) + 4 | 0) >> 2] = 0, o[pa >>
													2] = 0, 0 == (0 | (_a = 0 | o[1022]) & (ma = 1 << j))) {
												ya = _a | ma, o[1022] = ya, o[ca >> 2] = no, o[(no + 24 | 0) >> 2] = ca, o[(no + 12 | 0) >> 2] = no, o[(
													no + 8 | 0) >> 2] = no;
												break
											}
											for (D = F << (31 == (0 | j) ? 0 : 25 - (j >>> 1) | 0), Y = 0 | o[ca >> 2];;) {
												if ((0 | -8 & (0 | o[(Y + 4 | 0) >> 2])) == (0 | F)) {
													ku = 194;
													break
												}
												if (ba = D << 1, 0 == (0 | (va = 0 | o[(ga = (Y + 16 | 0) + (D >>> 31 << 2) | 0) >> 2]))) {
													ku = 193;
													break
												}
												D = ba, Y = va
											}
											if (193 == (0 | ku)) {
												o[ga >> 2] = no, o[(no + 24 | 0) >> 2] = Y, o[(no + 12 | 0) >> 2] = no, o[(no + 8 | 0) >> 2] = no;
												break
											}
											if (194 == (0 | ku)) {
												Ta = 0 | o[(Aa = Y + 8 | 0) >> 2], o[(Ta + 12 | 0) >> 2] = no, o[Aa >> 2] = no, o[(no + 8 | 0) >> 2] =
													Ta, o[(no + 12 | 0) >> 2] = Y, o[(no + 24 | 0) >> 2] = 0;
												break
											}
										}
									} while (0);
									return f = m, 0 | (Qi + 8 | 0)
								}
								for (E = 4532;
									(wa = 0 | o[E >> 2]) >>> 0 > vi >>> 0 || !((Ea = wa + (0 | o[(E + 4 | 0) >> 2]) | 0) >>> 0 > vi >>> 0);) E =
									0 | o[(E + 8 | 0) >> 2];
								for (Ba = (Pa = (Ia = (Sa = Ea + -47 | 0) + (0 == (0 | 7 & (ka = Sa + 8 | 0)) ? 0 : 7 & (0 - ka | 0)) | 0) >>>
										0 < (Oa = vi + 16 | 0) >>> 0 ? vi : Ia) + 8 | 0, Ca = Pa + 24 | 0, xa = Oe + (Na = 0 == (0 | 7 & (La = Oe +
										8 | 0)) ? 0 : 7 & (0 - La | 0)) | 0, Ua = (Ie + -40 | 0) - Na | 0, o[1027] = xa, o[1024] = Ua, Fa = 1 | Ua,
									o[(xa + 4 | 0) >> 2] = Fa, o[((xa + Ua | 0) + 4 | 0) >> 2] = 40, Ya = 0 | o[1143], o[1028] = Ya, o[(Ha = Pa +
										4 | 0) >> 2] = 27, o[Ba >> 2] = 0 | o[1133], o[Ba + 4 >> 2] = 0 | o[1134], o[Ba + 8 >> 2] = 0 | o[1135], o[
										Ba + 12 >> 2] = 0 | o[1136], o[1133] = Oe, o[1134] = Ie, o[1136] = 0, o[1135] = Ba, Wa = Ca; o[(ja = Wa +
										4 | 0) >> 2] = 7, (Wa + 8 | 0) >>> 0 < Ea >>> 0;) Wa = ja;
								if (!((0 | Pa) == (0 | vi))) {
									if (Va = Pa - vi | 0, Ka = -2 & (0 | o[Ha >> 2]), o[Ha >> 2] = Ka, Xa = 1 | Va, o[(vi + 4 | 0) >> 2] = Xa,
										o[Pa >> 2] = Va, Ga = Va >>> 3, Va >>> 0 < 256) {
										Ja = 4124 + (Ga << 1 << 2) | 0, 0 == (0 | ($a = 0 | o[1021]) & (qa = 1 << Ga)) ? (Za = $a | qa, o[1021] =
											Za, N = Ja, Be = Ja + 8 | 0) : (N = 0 | o[(Qa = Ja + 8 | 0) >> 2], Be = Qa), o[Be >> 2] = vi, o[(N + 12 |
											0) >> 2] = vi, o[(vi + 8 | 0) >> 2] = N, o[(vi + 12 | 0) >> 2] = Ja;
										break
									}
									if (lu = 4388 + ((x = 0 == (0 | (eu = Va >>> 8)) ? 0 : Va >>> 0 > 16777215 ? 31 : 1 & Va >>> ((su = (14 - (
											(ou = 4 & ((iu = eu << (nu = 8 & (eu + 1048320 | 0) >>> 16)) + 520192 | 0) >>> 16) | nu | (uu = 2 &
												((au = iu << ou) + 245760 | 0) >>> 16)) | 0) + (au << uu >>> 15) | 0) + 7 | 0) | su << 1) << 2) | 0, o[(
											vi + 28 | 0) >> 2] = x, o[(vi + 20 | 0) >> 2] = 0, o[Oa >> 2] = 0, 0 == (0 | (cu = 0 | o[1022]) & (du = 1 <<
											x))) {
										pu = cu | du, o[1022] = pu, o[lu >> 2] = vi, o[(vi + 24 | 0) >> 2] = lu, o[(vi + 12 | 0) >> 2] = vi, o[(vi +
											8 | 0) >> 2] = vi;
										break
									}
									for (C = Va << (31 == (0 | x) ? 0 : 25 - (x >>> 1) | 0), L = 0 | o[lu >> 2];;) {
										if ((0 | -8 & (0 | o[(L + 4 | 0) >> 2])) == (0 | Va)) {
											ku = 216;
											break
										}
										if (mu = C << 1, 0 == (0 | (yu = 0 | o[(_u = (L + 16 | 0) + (C >>> 31 << 2) | 0) >> 2]))) {
											ku = 215;
											break
										}
										C = mu, L = yu
									}
									if (215 == (0 | ku)) {
										o[_u >> 2] = vi, o[(vi + 24 | 0) >> 2] = L, o[(vi + 12 | 0) >> 2] = vi, o[(vi + 8 | 0) >> 2] = vi;
										break
									}
									if (216 == (0 | ku)) {
										bu = 0 | o[(gu = L + 8 | 0) >> 2], o[(bu + 12 | 0) >> 2] = vi, o[gu >> 2] = vi, o[(vi + 8 | 0) >> 2] = bu,
											o[(vi + 12 | 0) >> 2] = L, o[(vi + 24 | 0) >> 2] = 0;
										break
									}
								}
							}
						} while (0);
						if ((vu = 0 | o[1024]) >>> 0 > P >>> 0) return Au = vu - P | 0, o[1024] = Au, wu = (Tu = 0 | o[1027]) + P | 0,
							o[1027] = wu, Eu = 1 | Au, o[(wu + 4 | 0) >> 2] = Eu, Mu = 3 | P, o[(Tu + 4 | 0) >> 2] = Mu, f = m, 0 | (Tu +
								8 | 0)
					}
					return _ = 0 | q(), o[_ >> 2] = 12, f = m, 0 | 0
				}

				function G(e) {
					var t, r, n, i, a, u, s, f, l, c, d, h, p, _, m, y, g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						q = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						se = 0,
						fe = 0,
						le = 0,
						ce = 0,
						de = 0,
						he = 0,
						pe = 0,
						_e = 0,
						me = 0,
						ye = 0,
						ge = 0,
						be = 0,
						ve = 0,
						Ae = 0,
						Te = 0,
						we = 0,
						Ee = 0,
						Me = 0,
						Se = 0,
						ke = 0,
						Re = 0,
						Ie = 0,
						Oe = 0,
						Pe = 0,
						Be = 0,
						Ce = 0,
						Le = 0,
						Ne = 0,
						xe = 0,
						Ue = 0,
						Fe = 0,
						De = 0,
						Ye = 0,
						He = 0,
						je = 0,
						We = 0,
						ze = 0,
						Ve = 0,
						Ke = 0,
						Xe = 0,
						Ge = 0,
						Je = 0,
						$e = 0,
						qe = 0,
						Ze = 0,
						Qe = 0,
						et = 0,
						tt = 0,
						rt = 0,
						nt = 0,
						it = 0,
						ot = 0,
						at = 0,
						ut = 0,
						st = 0,
						ft = 0,
						lt = 0,
						ct = 0,
						dt = 0;
					if (!(0 == (0 | (e |= 0)))) {
						n = e + -8 | 0, c = 0 | o[1025], p = n + (h = -8 & (d = 0 | o[(e + -4 | 0) >> 2])) | 0, y = 0 == (0 | 1 & d);
						do {
							if (y) {
								if (B = 0 | o[n >> 2], 0 == (0 | 3 & d)) return;
								if (ne = B + h | 0, (Z = n + (0 - B | 0) | 0) >>> 0 < c >>> 0) return;
								if ((0 | Z) == (0 | (0 | o[1026]))) {
									if (!(3 == (0 | 3 & (rt = 0 | o[(tt = p + 4 | 0) >> 2])))) {
										T = Z, w = ne, ut = Z;
										break
									}
									return nt = Z + ne | 0, it = Z + 4 | 0, ot = 1 | ne, at = -2 & rt, o[1023] = ne, o[tt >> 2] = at, o[it >> 2] =
										ot, void(o[nt >> 2] = ne)
								}
								if (ge = B >>> 3, B >>> 0 < 256) {
									if (Me = 0 | o[(Z + 8 | 0) >> 2], (0 | (ke = 0 | o[(Z + 12 | 0) >> 2])) == (0 | Me)) {
										Ce = -1 ^ 1 << ge, Le = (0 | o[1021]) & Ce, o[1021] = Le, T = Z, w = ne, ut = Z;
										break
									}
									o[(Me + 12 | 0) >> 2] = ke, o[(ke + 8 | 0) >> 2] = Me, T = Z, w = ne, ut = Z;
									break
								}
								Ne = 0 | o[(Z + 24 | 0) >> 2], Ue = (0 | (xe = 0 | o[(Z + 12 | 0) >> 2])) == (0 | Z);
								do {
									if (Ue) {
										if (0 == (0 | (He = 0 | o[(Ye = (De = Z + 16 | 0) + 4 | 0) >> 2]))) {
											if (0 == (0 | (je = 0 | o[De >> 2]))) {
												I = 0;
												break
											}
											E = je, M = De
										} else E = He, M = Ye;
										for (;;)
											if (0 == (0 | (ze = 0 | o[(We = E + 20 | 0) >> 2]))) {
												if (0 == (0 | (Ke = 0 | o[(Ve = E + 16 | 0) >> 2]))) break;
												E = Ke, M = Ve
											} else E = ze, M = We;
										o[M >> 2] = 0, I = E
									} else Fe = 0 | o[(Z + 8 | 0) >> 2], o[(Fe + 12 | 0) >> 2] = xe, o[(xe + 8 | 0) >> 2] = Fe, I = xe
								} while (0);
								if (0 == (0 | Ne)) T = Z, w = ne, ut = Z;
								else {
									if (Xe = 0 | o[(Z + 28 | 0) >> 2], (0 | Z) == (0 | (0 | o[(Ge = 4388 + (Xe << 2) | 0) >> 2]))) {
										if (o[Ge >> 2] = I, 0 == (0 | I)) {
											Je = -1 ^ 1 << Xe, $e = (0 | o[1022]) & Je, o[1022] = $e, T = Z, w = ne, ut = Z;
											break
										}
									} else if (qe = 0 | o[(Ne + 16 | 0) >> 2], o[((Ne + 16 | 0) + ((1 & (0 | qe) != (0 | Z)) << 2) | 0) >> 2] =
										I, 0 == (0 | I)) {
										T = Z, w = ne, ut = Z;
										break
									}
									o[(I + 24 | 0) >> 2] = Ne, 0 == (0 | (Qe = 0 | o[(Ze = Z + 16 | 0) >> 2])) || (o[(I + 16 | 0) >> 2] = Qe, o[
										(Qe + 24 | 0) >> 2] = I), 0 == (0 | (et = 0 | o[(Ze + 4 | 0) >> 2])) ? (T = Z, w = ne, ut = Z) : (o[(I +
										20 | 0) >> 2] = et, o[(et + 24 | 0) >> 2] = I, T = Z, w = ne, ut = Z)
								}
							} else T = n, w = h, ut = n
						} while (0);
						if (ut >>> 0 < p >>> 0 && !(0 == (0 | 1 & (m = 0 | o[(_ = p + 4 | 0) >> 2])))) {
							if (0 == (0 | 2 & m)) {
								if (st = (0 | p) == (0 | (0 | o[1027])), ft = 0 | o[1026], st) {
									if (lt = (0 | o[1024]) + w | 0, o[1024] = lt, o[1027] = T, ct = 1 | lt, o[(T + 4 | 0) >> 2] = ct, !((0 | T) ==
											(0 | ft))) return;
									return o[1026] = 0, void(o[1023] = 0)
								}
								if ((0 | p) == (0 | ft)) return C = (0 | o[1023]) + w | 0, o[1023] = C, o[1026] = ut, L = 1 | C, o[(T + 4 |
									0) >> 2] = L, void(o[(ut + C | 0) >> 2] = C);
								N = (-8 & m) + w | 0, x = m >>> 3, U = m >>> 0 < 256;
								do {
									if (U) {
										if (F = 0 | o[(p + 8 | 0) >> 2], (0 | (D = 0 | o[(p + 12 | 0) >> 2])) == (0 | F)) {
											Y = -1 ^ 1 << x, H = (0 | o[1021]) & Y, o[1021] = H;
											break
										}
										o[(F + 12 | 0) >> 2] = D, o[(D + 8 | 0) >> 2] = F;
										break
									}
									j = 0 | o[(p + 24 | 0) >> 2], z = (0 | (W = 0 | o[(p + 12 | 0) >> 2])) == (0 | p);
									do {
										if (z) {
											if (0 == (0 | (G = 0 | o[(X = (K = p + 16 | 0) + 4 | 0) >> 2]))) {
												if (0 == (0 | (J = 0 | o[K >> 2]))) {
													O = 0;
													break
												}
												S = J, k = K
											} else S = G, k = X;
											for (;;)
												if (0 == (0 | (q = 0 | o[($ = S + 20 | 0) >> 2]))) {
													if (0 == (0 | (ee = 0 | o[(Q = S + 16 | 0) >> 2]))) break;
													S = ee, k = Q
												} else S = q, k = $;
											o[k >> 2] = 0, O = S
										} else V = 0 | o[(p + 8 | 0) >> 2], o[(V + 12 | 0) >> 2] = W, o[(W + 8 | 0) >> 2] = V, O = W
									} while (0);
									if (!(0 == (0 | j))) {
										if (te = 0 | o[(p + 28 | 0) >> 2], (0 | p) == (0 | (0 | o[(re = 4388 + (te << 2) | 0) >> 2]))) {
											if (o[re >> 2] = O, 0 == (0 | O)) {
												ie = -1 ^ 1 << te, oe = (0 | o[1022]) & ie, o[1022] = oe;
												break
											}
										} else if (ae = 0 | o[(j + 16 | 0) >> 2], o[((j + 16 | 0) + ((1 & (0 | ae) != (0 | p)) << 2) | 0) >> 2] =
											O, 0 == (0 | O)) break;
										o[(O + 24 | 0) >> 2] = j, 0 == (0 | (se = 0 | o[(ue = p + 16 | 0) >> 2])) || (o[(O + 16 | 0) >> 2] = se, o[
											(se + 24 | 0) >> 2] = O), 0 == (0 | (fe = 0 | o[(ue + 4 | 0) >> 2])) || (o[(O + 20 | 0) >> 2] = fe, o[(
											fe + 24 | 0) >> 2] = O)
									}
								} while (0);
								if (le = 1 | N, o[(T + 4 | 0) >> 2] = le, o[(ut + N | 0) >> 2] = N, (0 | T) == (0 | (0 | o[1026]))) return void(
									o[1023] = N);
								R = N
							} else ce = -2 & m, o[_ >> 2] = ce, de = 1 | w, o[(T + 4 | 0) >> 2] = de, o[(ut + w | 0) >> 2] = w, R = w;
							if (t = R >>> 3, R >>> 0 < 256) return he = 4124 + (t << 1 << 2) | 0, 0 == (0 | (pe = 0 | o[1021]) & (_e = 1 <<
									t)) ? (me = pe | _e, o[1021] = me, A = he, P = he + 8 | 0) : (A = 0 | o[(ye = he + 8 | 0) >> 2], P = ye),
								o[P >> 2] = T, o[(A + 12 | 0) >> 2] = T, o[(T + 8 | 0) >> 2] = A, void(o[(T + 12 | 0) >> 2] = he);
							i = 4388 + ((v = 0 == (0 | (r = R >>> 8)) ? 0 : R >>> 0 > 16777215 ? 31 : 1 & R >>> ((Ee = (14 - ((Ae = 4 & (
									(ve = r << (be = 8 & (r + 1048320 | 0) >>> 16)) + 520192 | 0) >>> 16) | be | (we = 2 & ((Te = ve <<
									Ae) + 245760 | 0) >>> 16)) | 0) + (Te << we >>> 15) | 0) + 7 | 0) | Ee << 1) << 2) | 0, o[(T + 28 | 0) >> 2] =
								v, a = T + 16 | 0, o[(T + 20 | 0) >> 2] = 0, o[a >> 2] = 0, f = 0 == (0 | (u = 0 | o[1022]) & (s = 1 << v));
							do {
								if (f) Se = u | s, o[1022] = Se, o[i >> 2] = T, o[(T + 24 | 0) >> 2] = i, o[(T + 12 | 0) >> 2] = T, o[(T + 8 |
									0) >> 2] = T;
								else {
									for (g = R << (31 == (0 | v) ? 0 : 25 - (v >>> 1) | 0), b = 0 | o[i >> 2];;) {
										if ((0 | -8 & (0 | o[(b + 4 | 0) >> 2])) == (0 | R)) {
											dt = 73;
											break
										}
										if (Ie = g << 1, 0 == (0 | (Oe = 0 | o[(Re = (b + 16 | 0) + (g >>> 31 << 2) | 0) >> 2]))) {
											dt = 72;
											break
										}
										g = Ie, b = Oe
									}
									if (72 == (0 | dt)) {
										o[Re >> 2] = T, o[(T + 24 | 0) >> 2] = b, o[(T + 12 | 0) >> 2] = T, o[(T + 8 | 0) >> 2] = T;
										break
									}
									if (73 == (0 | dt)) {
										Be = 0 | o[(Pe = b + 8 | 0) >> 2], o[(Be + 12 | 0) >> 2] = T, o[Pe >> 2] = T, o[(T + 8 | 0) >> 2] = Be, o[
											(T + 12 | 0) >> 2] = b, o[(T + 24 | 0) >> 2] = 0;
										break
									}
								}
							} while (0);
							l = (0 | o[1029]) + -1 | 0, o[1029] = l, 0 == (0 | l) && (o[1029] = -1)
						}
					}
				}

				function J(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var n, i, a, u, s, c, d, h, p, _, m, y, b, v, A, T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0;
					A = f, (0 | (f = f + 48 | 0)) >= (0 | l) && g(48), v = A + 16 | 0, b = A, d = A + 32 | 0, p = 0 | o[(h = e + 28 |
							0) >> 2], o[d >> 2] = p, _ = d + 4 | 0, y = (0 | o[(m = e + 20 | 0) >> 2]) - p | 0, o[_ >> 2] = y, o[(d + 8 |
							0) >> 2] = t, o[(d + 12 | 0) >> 2] = r, n = y + r | 0, a = 0 | o[(i = e + 60 | 0) >> 2], u = d, o[b >> 2] = a,
						o[(b + 4 | 0) >> 2] = u, o[(b + 8 | 0) >> 2] = 2, c = (0 | n) == (0 | (s = 0 | $(0 | R(146, 0 | b))));
					e: do {
						if (c) W = 3;
						else {
							for (w = 2, E = n, M = d, B = s; !((0 | B) < 0);) {
								if (L = E - B | 0, k = ((x = B >>> 0 > (N = 0 | o[(M + 4 | 0) >> 2]) >>> 0) << 31 >> 31) + w | 0, T = B - (
										x ? N : 0) | 0, U = (0 | o[(I = x ? M + 8 | 0 : M) >> 2]) + T | 0, o[I >> 2] = U, D = (0 | o[(F = I + 4 |
										0) >> 2]) - T | 0, o[F >> 2] = D, Y = 0 | o[i >> 2], H = I, o[v >> 2] = Y, o[(v + 4 | 0) >> 2] = H, o[(v +
										8 | 0) >> 2] = k, (0 | L) == (0 | (j = 0 | $(0 | R(146, 0 | v))))) {
									W = 3;
									break e
								}
								w = k, E = L, M = I, B = j
							}
							o[(e + 16 | 0) >> 2] = 0, o[h >> 2] = 0, o[m >> 2] = 0, C = 32 | (0 | o[e >> 2]), o[e >> 2] = C, S = 2 == (0 |
								w) ? 0 : r - (0 | o[(M + 4 | 0) >> 2]) | 0
						}
					} while (0);
					return 3 == (0 | W) && (P = (O = 0 | o[(e + 44 | 0) >> 2]) + (0 | o[(e + 48 | 0) >> 2]) | 0, o[(e + 16 | 0) >>
						2] = P, o[h >> 2] = O, o[m >> 2] = O, S = r), f = A, 0 | S
				}

				function $(e) {
					var t = 0,
						r = 0,
						n = 0;
					return (e |= 0) >>> 0 > 4294963200 ? (r = 0 - e | 0, n = 0 | q(), o[n >> 2] = r, t = -1) : t = e, 0 | t
				}

				function q() {
					return 8, 72, 72
				}

				function Z(e) {
					var t, r, i = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0;
					r = 0 == (0 | 3 & (t = e |= 0));
					e: do {
						if (r) a = e, y = 4;
						else
							for (u = e, p = t;;) {
								if ((0 | n[u >> 0]) << 24 >> 24 == 0) {
									l = p;
									break e
								}
								if (0 == (0 | 3 & (m = _ = u + 1 | 0))) {
									a = _, y = 4;
									break
								}
								u = _, p = m
							}
					} while (0);
					if (4 == (0 | y)) {
						for (i = a; d = i + 4 | 0, 0 == (0 | (-2139062144 ^ -2139062144 & (c = 0 | o[i >> 2])) & (c + -16843009 | 0));)
							i = d;
						if ((255 & c) << 24 >> 24 == 0) s = i;
						else
							for (f = i;;) {
								if ((0 | n[(h = f + 1 | 0) >> 0]) << 24 >> 24 == 0) {
									s = h;
									break
								}
								f = h
							}
						l = s
					}
					return 0 | (l - t | 0)
				}

				function Q(e) {
					return 8, 196, 0 | (0 | ee(e |= 0, 0 | o[49]))
				}

				function ee(e, t) {
					e |= 0, t |= 0;
					var r = 0,
						i = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0;
					for (a = 0;;) {
						if ((0 | 255 & (0 | n[(1644 + a | 0) >> 0])) == (0 | e)) {
							d = 2;
							break
						}
						if (87 == (0 | (c = a + 1 | 0))) {
							i = 1732, s = 87, d = 5;
							break
						}
						a = c
					}
					if (2 == (0 | d) && (0 == (0 | a) ? r = 1732 : (i = 1732, s = a, d = 5)), 5 == (0 | d))
						for (;;) {
							for (d = 0, u = i; f = u + 1 | 0, !((0 | n[u >> 0]) << 24 >> 24 == 0);) u = f;
							if (0 == (0 | (l = s + -1 | 0))) {
								r = f;
								break
							}
							i = f, s = l, d = 5
						}
					return 0 | (0 | function(e, t) {
						return 0 | (0 | function(e, t) {
							e |= 0;
							var r = 0,
								n = 0,
								i = 0,
								a = 0;
							return 0 == (0 | (t |= 0)) ? r = 0 : (n = 0 | o[t >> 2], i = 0 | o[(t + 4 | 0) >> 2], a = 0 | te(n, i, e),
								r = a), 0 | (0 != (0 | r) ? r : e)
						}(e |= 0, t |= 0))
					}(r, 0 | o[(t + 20 | 0) >> 2]))
				}

				function te(e, t, r) {
					t |= 0, r |= 0;
					var i, a, u, s, f, l = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0;
					s = (0 | o[(e |= 0) >> 2]) + 1794895138 | 0, f = 0 | re(0 | o[(e + 8 | 0) >> 2], s), i = 0 | re(0 | o[(e + 12 |
						0) >> 2], s), a = 0 | re(0 | o[(e + 16 | 0) >> 2], s), u = f >>> 0 < t >>> 2 >>> 0;
					e: do {
						if (u)
							if (i >>> 0 < (_ = t - (f << 2) | 0) >>> 0 & a >>> 0 < _ >>> 0)
								if (0 == (0 | 3 & (a | i))) {
									for (m = i >>> 2, y = a >>> 2, l = 0, c = f;;) {
										if (T = 0 | re(0 | o[(e + ((A = (v = (b = l + (g = c >>> 1) | 0) << 1) + m | 0) << 2) | 0) >> 2], s), !((
													w = 0 | re(0 | o[(e + ((A + 1 | 0) << 2) | 0) >> 2], s)) >>> 0 < t >>> 0 & T >>> 0 < (t - w | 0) >>>
												0)) {
											p = 0;
											break e
										}
										if (!((0 | n[(e + (w + T | 0) | 0) >> 0]) << 24 >> 24 == 0)) {
											p = 0;
											break e
										}
										if (0 == (0 | (E = 0 | ne(r, e + w | 0)))) break;
										if (h = (I = (0 | E) < 0) ? g : c - g | 0, d = I ? l : b, 1 == (0 | c)) {
											p = 0;
											break e
										}
										l = d, c = h
									}
									S = 0 | re(0 | o[(e + ((M = v + y | 0) << 2) | 0) >> 2], s), (k = 0 | re(0 | o[(e + ((M + 1 | 0) << 2) | 0) >>
										2], s)) >>> 0 < t >>> 0 & S >>> 0 < (t - k | 0) >>> 0 ? (R = e + k | 0, p = (0 | n[(e + (k + S | 0) | 0) >>
										0]) << 24 >> 24 == 0 ? R : 0) : p = 0
								} else p = 0;
						else p = 0;
						else p = 0
					} while (0);
					return 0 | p
				}

				function re(e, t) {
					var r, n;
					return r = 0 == (0 | (t |= 0)), n = 0 | Le(0 | (e |= 0)), 0 | (r ? e : n)
				}

				function ne(e, t) {
					t |= 0;
					var r, i, o = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0;
					if ((r = 0 | n[(e |= 0) >> 0]) << 24 >> 24 == 0 | r << 24 >> 24 != (i = 0 | n[t >> 0]) << 24 >> 24) u = i, s =
						r;
					else
						for (o = t, a = e;;) {
							if (l = o + 1 | 0, (c = 0 | n[(f = a + 1 | 0) >> 0]) << 24 >> 24 == 0 | c << 24 >> 24 != (d = 0 | n[l >> 0]) <<
								24 >> 24) {
								u = d, s = c;
								break
							}
							o = l, a = f
						}
					return 0 | ((255 & s) - (255 & u) | 0)
				}

				function ie(e, t, r) {
					var i, a, u, s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0;
					i = 255 & (t |= 0), u = (a = 0 != (0 | (r |= 0))) & 0 != (0 | 3 & (e |= 0));
					e: do {
						if (u)
							for (N = 255 & t, c = e, _ = r;;) {
								if ((0 | n[c >> 0]) << 24 >> 24 == N << 24 >> 24) {
									l = c, p = _, x = 6;
									break e
								}
								if (!((S = 0 != (0 | (M = _ + -1 | 0))) & 0 != (0 | 3 & (E = c + 1 | 0)))) {
									f = E, d = M, w = S, x = 5;
									break
								}
								c = E, _ = M
							} else f = e, d = r, w = a, x = 5
					} while (0);
					5 == (0 | x) && (w ? (l = f, p = d, x = 6) : (v = f, T = 0));
					e: do {
						if (6 == (0 | x))
							if ((0 | n[l >> 0]) << 24 >> 24 == (k = 255 & t) << 24 >> 24) v = l, T = p;
							else {
								R = 0 | h(i, 16843009), I = p >>> 0 > 3;
								t: do {
									if (I) {
										for (m = l, g = p; 0 == (0 | (-2139062144 ^ -2139062144 & (O = (0 | o[m >> 2]) ^ R)) & (O + -16843009 |
												0));) {
											if (P = m + 4 | 0, !((B = g + -4 | 0) >>> 0 > 3)) {
												s = P, y = B, x = 11;
												break t
											}
											m = P, g = B
										}
										b = m, A = g
									} else s = l, y = p, x = 11
								} while (0);
								if (11 == (0 | x)) {
									if (0 == (0 | y)) {
										v = s, T = 0;
										break
									}
									b = s, A = y
								}
								for (;;) {
									if ((0 | n[b >> 0]) << 24 >> 24 == k << 24 >> 24) {
										v = b, T = A;
										break e
									}
									if (C = b + 1 | 0, 0 == (0 | (L = A + -1 | 0))) {
										v = C, T = 0;
										break
									}
									b = C, A = L
								}
							}
					} while (0);
					return 0 | (0 != (0 | T) ? v : 0)
				}

				function oe(e, t, r) {
					e |= 0, t |= 0, r |= 0;
					var n, i, a;
					return a = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), o[(n = a) >> 2] = r, i = 0 | function(e, t, r) {
						return 0 | (0 | ae(e |= 0, 2147483647, t |= 0, r |= 0))
					}(e, t, n), f = a, 0 | i
				}

				function ae(e, t, r, i) {
					e |= 0, t |= 0, r |= 0, i |= 0;
					var a, u, s, c, d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0;
					s = f, (0 | (f = f + 128 | 0)) >= (0 | l) && g(128), a = s + 124 | 0, k = 380, c = (M = u = s) + 124 | 0;
					do {
						o[M >> 2] = 0 | o[k >> 2], M = M + 4 | 0, k = k + 4 | 0
					} while ((0 | M) < (0 | c));
					return (t + -1 | 0) >>> 0 > 2147483646 ? 0 == (0 | t) ? (p = a, _ = 1, S = 4) : (E = 0 | q(), o[E >> 2] = 75, h = -
						1) : (p = e, _ = t, S = 4), 4 == (0 | S) && (d = _ >>> 0 > (m = -2 - p | 0) >>> 0 ? m : _, o[(u + 48 | 0) >>
							2] = d, o[(y = u + 20 | 0) >> 2] = p, o[(u + 44 | 0) >> 2] = p, b = p + d | 0, o[(v = u + 16 | 0) >> 2] = b,
						o[(u + 28 | 0) >> 2] = b, A = 0 | function(e, t, r) {
							e |= 0, t |= 0, r |= 0;
							var i = 0,
								a = 0,
								u = 0,
								s = 0,
								c = 0,
								d = 0,
								h = 0,
								p = 0,
								_ = 0,
								m = 0,
								y = 0,
								b = 0,
								v = 0,
								A = 0,
								T = 0,
								w = 0,
								E = 0,
								M = 0,
								S = 0,
								k = 0,
								R = 0,
								I = 0,
								O = 0,
								P = 0,
								B = 0,
								C = 0,
								L = 0,
								N = 0,
								x = 0,
								U = 0,
								F = 0;
							U = f, (0 | (f = f + 224 | 0)) >= (0 | l) && g(224);
							S = U + 120 | 0, B = U, C = U + 136 | 0, F = 40 + (x = P = U + 80 | 0) | 0;
							do {
								o[x >> 2] = 0, x = x + 4 | 0
							} while ((0 | x) < (0 | F));
							N = 0 | o[r >> 2], o[S >> 2] = N, L = 0 | ue(0, t, S, B, P), (0 | L) < 0 ? a = -1 : (c = 0 | o[e >> 2], d =
								32 & c, h = 0 | n[(e + 74 | 0) >> 0], h << 24 >> 24 < 1 && (p = -33 & c, o[e >> 2] = p), m = 0 | o[(_ = e +
									48 | 0) >> 2], 0 == (0 | m) ? (v = 0 | o[(b = e + 44 | 0) >> 2], o[b >> 2] = C, o[(A = e + 28 | 0) >> 2] =
									C, o[(T = e + 20 | 0) >> 2] = C, o[_ >> 2] = 80, w = C + 80 | 0, o[(E = e + 16 | 0) >> 2] = w, M = 0 | ue(
										e, t, S, B, P), 0 == (0 | v) ? u = M : (k = 0 | o[(e + 36 | 0) >> 2], Ue[7 & k](e, 0, 0), R = 0 | o[T >>
											2], i = 0 == (0 | R) ? -1 : M, o[b >> 2] = v, o[_ >> 2] = 0, o[E >> 2] = 0, o[A >> 2] = 0, o[T >> 2] =
										0, u = i)) : (y = 0 | ue(e, t, S, B, P), u = y), I = 0 | o[e >> 2], s = 0 == (0 | 32 & I) ? u : -1, O =
								I | d, o[e >> 2] = O, a = s);
							return f = U, 0 | a
						}(u, r, i), 0 == (0 | d) ? h = A : (T = 0 | o[y >> 2], w = 0 | o[v >> 2], n[(T + (((0 | T) == (0 | w)) << 31 >>
							31) | 0) >> 0] = 0, h = A)), f = s, 0 | h
				}

				function ue(e, t, r, u, s) {
					e |= 0, t |= 0, r |= 0, u |= 0, s |= 0;
					var c, h, p, _, m, y, b, v, A, T, w, E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						Z = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						ye = 0,
						ge = 0,
						be = 0,
						ve = 0,
						Ae = 0,
						Te = 0,
						Ee = 0,
						Me = 0,
						Se = 0,
						ke = 0,
						Re = 0,
						Ie = 0,
						Oe = 0,
						Pe = 0,
						Be = 0,
						Ce = 0,
						Le = 0,
						Ne = 0,
						xe = 0,
						Ue = 0,
						Fe = 0,
						De = 0,
						Ye = 0,
						He = 0,
						je = 0,
						We = 0,
						ze = 0,
						Ve = 0,
						Ke = 0,
						Xe = 0,
						Ge = 0,
						Je = 0,
						$e = 0,
						qe = 0,
						Ze = 0,
						Qe = 0,
						et = 0,
						tt = 0,
						rt = 0,
						nt = 0,
						it = 0,
						ot = 0,
						at = 0,
						ut = 0,
						st = 0,
						ft = 0,
						lt = 0,
						ct = 0,
						dt = 0,
						ht = 0,
						pt = 0,
						_t = 0,
						mt = 0,
						yt = 0,
						gt = 0,
						bt = 0,
						vt = 0,
						At = 0,
						Tt = 0,
						wt = 0,
						Et = 0,
						Mt = 0,
						St = 0,
						kt = 0,
						Rt = 0,
						It = 0,
						Ot = 0,
						Pt = 0,
						Bt = 0,
						Ct = 0,
						Lt = 0,
						Nt = 0,
						xt = 0,
						Ut = 0,
						Ft = 0,
						Dt = 0,
						Yt = 0,
						Ht = 0,
						jt = 0,
						Wt = 0,
						zt = 0,
						Vt = 0,
						Kt = 0,
						Xt = 0,
						Gt = 0,
						Jt = 0,
						$t = 0,
						qt = 0,
						Zt = 0,
						Qt = 0,
						er = 0,
						tr = 0,
						rr = 0,
						nr = 0,
						ir = 0,
						or = 0,
						ar = 0,
						ur = 0,
						sr = 0,
						fr = 0,
						lr = 0,
						cr = 0,
						dr = 0,
						hr = 0,
						pr = 0,
						_r = 0,
						mr = 0,
						yr = 0,
						gr = 0,
						br = 0,
						vr = 0,
						Ar = 0,
						Tr = 0,
						wr = 0,
						Er = 0,
						Mr = 0,
						Sr = 0,
						kr = 0,
						Rr = 0,
						Ir = 0,
						Or = 0,
						Pr = 0,
						Br = 0,
						Cr = 0,
						Lr = 0,
						Nr = 0,
						xr = 0,
						Ur = 0,
						Fr = 0,
						Dr = 0,
						Yr = 0,
						Hr = 0,
						jr = 0,
						Wr = 0,
						zr = 0,
						Vr = 0,
						Kr = 0,
						Xr = 0,
						Gr = 0;
					w = f, (0 | (f = f + 64 | 0)) >= (0 | l) && g(64), b = w, v = w + 24 | 0, A = w + 8 | 0, T = w + 20 | 0, o[(y =
							w + 16 | 0) >> 2] = t, c = 0 != (0 | e), p = h = v + 40 | 0, _ = v + 39 | 0, m = A + 4 | 0, L = 0, N = 0, z =
						0, At = t;
					e: for (;;) {
						qe = (0 | N) > -1;
						do {
							if (qe) {
								if ((0 | L) > (0 | (2147483647 - N | 0))) {
									st = 0 | q(), o[st >> 2] = 75, ee = -1;
									break
								}
								ee = L + N | 0;
								break
							}
							ee = N
						} while (0);
						if ((bt = 0 | n[At >> 0]) << 24 >> 24 == 0) {
							Gr = 87;
							break
						}
						Ot = bt, Dt = At;
						t: for (;;) {
							switch (Ot << 24 >> 24) {
								case 37:
									U = Dt, Vt = Dt, Gr = 9;
									break t;
								case 0:
									x = Dt, _r = Dt;
									break t
							}
							Lt = Dt + 1 | 0, o[y >> 2] = Lt, Ot = 0 | n[Lt >> 0], Dt = Lt
						}
						t: do {
							if (9 == (0 | Gr))
								for (;;) {
									if (Gr = 0, !((0 | n[(Vt + 1 | 0) >> 0]) << 24 >> 24 == 37)) {
										x = U, _r = Vt;
										break t
									}
									if (rr = U + 1 | 0, ir = Vt + 2 | 0, o[y >> 2] = ir, !((0 | n[ir >> 0]) << 24 >> 24 == 37)) {
										x = rr, _r = ir;
										break
									}
									U = rr, Vt = ir, Gr = 9
								}
						} while (0);
						if (hr = x - At | 0, c && se(e, At, hr), 0 == (0 | hr)) {
							(Yr = ((0 | n[(pr = _r + 1 | 0) >> 0]) << 24 >> 24) + -48 | 0) >>> 0 < 10 ? (D = (mr = (0 | n[(_r + 2 | 0) >>
									0]) << 24 >> 24 == 36) ? Yr : -1, ae = mr ? 1 : z, Vr = mr ? _r + 3 | 0 : pr) : (D = -1, ae = z, Vr = pr),
								o[y >> 2] = Vr, br = (gr = ((yr = 0 | n[Vr >> 0]) << 24 >> 24) + -32 | 0) >>> 0 < 32;
							t: do {
								if (br)
									for (W = 0, lr = yr, Ar = gr, Kr = Vr;;) {
										if (0 == (0 | 75913 & (vr = 1 << Ar))) {
											j = W, Ce = lr, kr = Kr;
											break t
										}
										if (Tr = vr | W, wr = Kr + 1 | 0, o[y >> 2] = wr, !((Mr = ((Er = 0 | n[wr >> 0]) << 24 >> 24) + -32 | 0) >>>
												0 < 32)) {
											j = Tr, Ce = Er, kr = wr;
											break
										}
										W = Tr, lr = Er, Ar = Mr, Kr = wr
									} else j = 0, Ce = yr, kr = Vr
							} while (0);
							if (Ce << 24 >> 24 == 42) {
								if ((jr = ((0 | n[(Sr = kr + 1 | 0) >> 0]) << 24 >> 24) + -48 | 0) >>> 0 < 10 && (0 | n[(kr + 2 | 0) >> 0]) <<
									24 >> 24 == 36 ? (o[(s + (jr << 2) | 0) >> 2] = 10, Rr = 0 | n[Sr >> 0], H = 0 | o[(u + (((Rr << 24 >> 24) +
										-48 | 0) << 3) | 0) >> 2], Me = 1, Xr = kr + 3 | 0) : Gr = 23, 23 == (0 | Gr)) {
									if (Gr = 0, !(0 == (0 | ae))) {
										M = -1;
										break
									}
									c ? (xr = 0 | o[r >> 2], Or = 0 | o[(Ir = (xr + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], Fr = Ir + 4 |
										0, o[r >> 2] = Fr, H = Or, Me = 0, Xr = Sr) : (H = 0, Me = 0, Xr = Sr)
								}
								o[y >> 2] = Xr, re = (Pr = (0 | H) < 0) ? 0 - H | 0 : H, ne = Pr ? 8192 | j : j, ke = Me, Cr = Xr
							} else {
								if ((0 | (Br = 0 | fe(y))) < 0) {
									M = -1;
									break
								}
								re = Br, ne = j, ke = ae, Cr = 0 | o[y >> 2]
							}
							Lr = (0 | n[Cr >> 0]) << 24 >> 24 == 46;
							do {
								if (Lr) {
									if (!((0 | n[(Cr + 1 | 0) >> 0]) << 24 >> 24 == 42)) {
										He = Cr + 1 | 0, o[y >> 2] = He, Y = 0 | fe(y), Le = 0 | o[y >> 2];
										break
									}
									if ((Hr = ((0 | n[(Nr = Cr + 2 | 0) >> 0]) << 24 >> 24) + -48 | 0) >>> 0 < 10 && (0 | n[(Cr + 3 | 0) >> 0]) <<
										24 >> 24 == 36) {
										o[(s + (Hr << 2) | 0) >> 2] = 10, xe = 0 | n[Nr >> 0], Ue = 0 | o[(u + (((xe << 24 >> 24) + -48 | 0) << 3) |
											0) >> 2], Fe = Cr + 4 | 0, o[y >> 2] = Fe, Y = Ue, Le = Fe;
										break
									}
									if (!(0 == (0 | ke))) {
										M = -1;
										break e
									}
									c ? (Ur = 0 | o[r >> 2], Ye = 0 | o[(De = (Ur + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], Dr = De + 4 |
										0, o[r >> 2] = Dr, cr = Ye) : cr = 0, o[y >> 2] = Nr, Y = cr, Le = Nr
								} else Y = -1, Le = Cr
							} while (0);
							for (F = 0, je = Le;;) {
								if ((((0 | n[je >> 0]) << 24 >> 24) + -65 | 0) >>> 0 > 57) {
									M = -1;
									break e
								}
								if (We = je + 1 | 0, o[y >> 2] = We, ze = 0 | n[je >> 0], !(((Ke = 255 & (Ve = 0 | n[((3536 + (58 * F | 0) |
										0) + ((ze << 24 >> 24) + -65 | 0) | 0) >> 0])) + -1 | 0) >>> 0 < 8)) break;
								F = Ke, je = We
							}
							if (Ve << 24 >> 24 == 0) {
								M = -1;
								break
							}
							Xe = Ve << 24 >> 24 == 19, Ge = (0 | D) > -1;
							do {
								if (Xe) {
									if (Ge) {
										M = -1;
										break e
									}
									Gr = 49
								} else {
									if (Ge) {
										o[(s + (D << 2) | 0) >> 2] = Ke, $e = 0 | o[(Je = u + (D << 3) | 0) >> 2], Ze = 0 | o[(Je + 4 | 0) >> 2],
											o[(Qe = b) >> 2] = $e, o[(Qe + 4 | 0) >> 2] = Ze, Gr = 49;
										break
									}
									if (!c) {
										M = 0;
										break e
									}
									le(b, Ke, r)
								}
							} while (0);
							if (49 != (0 | Gr) || (Gr = 0, c)) {
								I = 0 != (0 | F) & 3 == (0 | 15 & (et = (0 | n[je >> 0]) << 24 >> 24)) ? -33 & et : et, tt = -65537 & ne,
									oe = 0 == (0 | 8192 & ne) ? ne : tt;
								t: do {
									switch (0 | I) {
										case 110:
											switch ((255 & F) << 24 >> 24) {
												case 0:
													nt = 0 | o[b >> 2], o[nt >> 2] = ee, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 1:
													it = 0 | o[b >> 2], o[it >> 2] = ee, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 2:
													ot = ((0 | ee) < 0) << 31 >> 31, at = 0 | o[b >> 2], o[(ut = at) >> 2] = ee, o[(ut + 4 | 0) >> 2] =
														ot, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 3:
													ft = 65535 & ee, lt = 0 | o[b >> 2], i[lt >> 1] = ft, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 4:
													ct = 255 & ee, dt = 0 | o[b >> 2], n[dt >> 0] = ct, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 6:
													ht = 0 | o[b >> 2], o[ht >> 2] = ee, L = 0, N = ee, z = ke, At = We;
													continue e;
												case 7:
													pt = ((0 | ee) < 0) << 31 >> 31, _t = 0 | o[b >> 2], o[(mt = _t) >> 2] = ee, o[(mt + 4 | 0) >> 2] =
														pt, L = 0, N = ee, z = ke, At = We;
													continue e;
												default:
													L = 0, N = ee, z = ke, At = We;
													continue e
											}
											break;
										case 112:
											G = 120, te = Y >>> 0 > 8 ? Y : 8, Se = 8 | oe, Gr = 61;
											break;
										case 88:
										case 120:
											G = I, te = Y, Se = oe, Gr = 61;
											break;
										case 111:
											S = Mt = 0 | de(wt = 0 | o[(Tt = b) >> 2], Et = 0 | o[(Tt + 4 | 0) >> 2], h), X = 0, J = 4e3, Te = 0 ==
												(0 | 8 & oe) | (0 | Y) > (0 | (St = p - Mt | 0)) ? Y : St + 1 | 0, Oe = oe, Ut = wt, Ft = Et, Gr = 67;
											break;
										case 105:
										case 100:
											if (Rt = 0 | o[(kt = b) >> 2], (0 | (It = 0 | o[(kt + 4 | 0) >> 2])) < 0) {
												Pt = 0 | we(0, 0, 0 | Rt, 0 | It), Bt = d, o[(Ct = b) >> 2] = Pt, o[(Ct + 4 | 0) >> 2] = Bt, R = 1, O =
													4e3, Nt = Pt, xt = Bt, Gr = 66;
												break t
											}
											R = 1 & 0 != (0 | 2049 & oe), O = 0 == (0 | 2048 & oe) ? 0 == (0 | 1 & oe) ? 4e3 : 4002 : 4001, Nt = Rt,
												xt = It, Gr = 66;
											break t;
										case 117:
											R = 0, O = 4e3, Nt = 0 | o[(rt = b) >> 2], xt = 0 | o[(rt + 4 | 0) >> 2], Gr = 66;
											break;
										case 99:
											jt = 255 & (0 | o[b >> 2]), n[_ >> 0] = jt, ue = _, ye = 0, ge = 4e3, Ae = h, Pe = 1, Be = tt;
											break;
										case 109:
											Wt = 0 | q(), V = 0 | Q(0 | o[Wt >> 2]), Gr = 71;
											break;
										case 115:
											V = 0 != (0 | (zt = 0 | o[b >> 2])) ? zt : 4010, Gr = 71;
											break;
										case 67:
											Gt = 0 | o[b >> 2], o[A >> 2] = Gt, o[m >> 2] = 0, o[b >> 2] = A, Ie = -1, dr = A, Gr = 75;
											break;
										case 83:
											Ne = 0 | o[b >> 2], 0 == (0 | Y) ? (pe(e, 32, re, 0, oe), B = 0, Gr = 84) : (Ie = Y, dr = Ne, Gr = 75);
											break;
										case 65:
										case 71:
										case 70:
										case 69:
										case 97:
										case 103:
										case 102:
										case 101:
											L = 0 | me(e, +a[b >> 3], re, Y, oe, I), N = ee, z = ke, At = We;
											continue e;
										default:
											ue = At, ye = 0, ge = 4e3, Ae = h, Pe = Y, Be = oe
									}
								} while (0);
								t: do {
									if (61 == (0 | Gr)) Gr = 0, S = 0 | ce(gt = 0 | o[(yt = b) >> 2], vt = 0 | o[(yt + 4 | 0) >> 2], h, 32 &
											G), X = (zr = 0 == (0 | 8 & Se) | 0 == (0 | gt) & 0 == (0 | vt)) ? 0 : 2, J = zr ? 4e3 : 4e3 + (G >> 4) |
										0, Te = te, Oe = Se, Ut = gt, Ft = vt, Gr = 67;
									else if (66 == (0 | Gr)) Gr = 0, S = 0 | he(Nt, xt, h), X = R, J = O, Te = Y, Oe = oe, Ut = Nt, Ft = xt,
										Gr = 67;
									else if (71 == (0 | Gr)) Gr = 0, ue = V, ye = 0, ge = 4e3, Ae = (Xt = 0 == (0 | (Kt = 0 | ie(V, 0, Y)))) ?
										V + Y | 0 : Kt, Pe = Xt ? Y : Kt - V | 0, Be = tt;
									else if (75 == (0 | Gr)) {
										for (Gr = 0, k = dr, C = 0, Z = 0;;) {
											if (0 == (0 | (Jt = 0 | o[k >> 2]))) {
												P = C, ve = Z;
												break
											}
											if ((0 | ($t = 0 | _e(T, Jt))) < 0 | $t >>> 0 > (Ie - C | 0) >>> 0) {
												P = C, ve = $t;
												break
											}
											if (qt = k + 4 | 0, !(Ie >>> 0 > (Zt = $t + C | 0) >>> 0)) {
												P = Zt, ve = $t;
												break
											}
											k = qt, C = Zt, Z = $t
										}
										if ((0 | ve) < 0) {
											M = -1;
											break e
										}
										if (pe(e, 32, re, P, oe), 0 == (0 | P)) B = 0, Gr = 84;
										else
											for (K = dr, $ = 0;;) {
												if (0 == (0 | (Qt = 0 | o[K >> 2]))) {
													B = P, Gr = 84;
													break t
												}
												if ((0 | (tr = (er = 0 | _e(T, Qt)) + $ | 0)) > (0 | P)) {
													B = P, Gr = 84;
													break t
												}
												if (nr = K + 4 | 0, se(e, T, er), !(tr >>> 0 < P >>> 0)) {
													B = P, Gr = 84;
													break
												}
												K = nr, $ = tr
											}
									}
								} while (0);
								if (67 == (0 | Gr)) Gr = 0, Ht = (1 & (1 ^ (Yt = 0 != (0 | Ut) | 0 != (0 | Ft)))) + (p - S | 0) | 0, ue = (
										Wr = 0 != (0 | Te) | Yt) ? S : h, ye = X, ge = J, Ae = h, Pe = Wr ? (0 | Te) > (0 | Ht) ? Te : Ht : Te,
									Be = (0 | Te) > -1 ? -65537 & Oe : Oe;
								else if (84 == (0 | Gr)) {
									Gr = 0, pe(e, 32, re, B, 8192 ^ oe), L = (0 | re) > (0 | B) ? re : B, N = ee, z = ke, At = We;
									continue
								}
								pe(e, 32, Ee = (0 | re) < (0 | (ar = (E = (0 | Pe) < (0 | (or = Ae - ue | 0)) ? or : Pe) + ye | 0)) ? ar :
									re, ar, Be), se(e, ge, ye), pe(e, 48, Ee, ar, 65536 ^ Be), pe(e, 48, E, or, 0), se(e, ue, or), pe(e, 32,
									Ee, ar, 8192 ^ Be), L = Ee, N = ee, z = ke, At = We
							} else L = 0, N = ee, z = ke, At = We
						} else L = hr, N = ee, At = _r, z = z
					}
					e: do {
						if (87 == (0 | Gr))
							if (0 == (0 | e))
								if (0 == (0 | z)) M = 0;
								else {
									for (be = 1;;) {
										if (0 == (0 | (ur = 0 | o[(s + (be << 2) | 0) >> 2]))) {
											Re = be;
											break
										}
										if (le(u + (be << 3) | 0, ur, r), !((0 | (sr = be + 1 | 0)) < 10)) {
											M = 1;
											break e
										}
										be = sr
									}
									for (;;) {
										if (fr = Re + 1 | 0, !(0 == (0 | (0 | o[(s + (Re << 2) | 0) >> 2])))) {
											M = -1;
											break e
										}
										if (!((0 | fr) < 10)) {
											M = 1;
											break
										}
										Re = fr
									}
								}
						else M = ee
					} while (0);
					return f = w, 0 | M
				}

				function se(e, t, r) {
					t |= 0, r |= 0;
					0 == (0 | 32 & (0 | o[(e |= 0) >> 2])) && Ae(t, r, e)
				}

				function fe(e) {
					var t, r, i = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0;
					if (t = 0 | o[(e |= 0) >> 2], (r = ((0 | n[t >> 0]) << 24 >> 24) + -48 | 0) >>> 0 < 10)
						for (a = 0, f = t, c = r;;) {
							if (u = c + (10 * a | 0) | 0, s = f + 1 | 0, o[e >> 2] = s, !((l = ((0 | n[s >> 0]) << 24 >> 24) + -48 | 0) >>>
									0 < 10)) {
								i = u;
								break
							}
							a = u, f = s, c = l
						} else i = 0;
					return 0 | i
				}

				function le(e, t, r) {
					e |= 0, r |= 0;
					var n, i = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						q = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0;
					n = (t |= 0) >>> 0 > 20;
					e: do {
						if (!n) {
							switch (0 | t) {
								case 9:
									j = 0 | o[r >> 2], s = 0 | o[(F = (j + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], Z = F + 4 | 0, o[r >>
										2] = Z, o[e >> 2] = s;
									break e;
								case 10:
									K = 0 | o[r >> 2], p = 0 | o[(h = (K + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], oe = h + 4 | 0, o[r >>
										2] = oe, _ = ((0 | p) < 0) << 31 >> 31, o[(m = e) >> 2] = p, o[(m + 4 | 0) >> 2] = _;
									break e;
								case 11:
									$ = 0 | o[r >> 2], g = 0 | o[(y = ($ + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], ae = y + 4 | 0, o[r >>
										2] = ae, o[(b = e) >> 2] = g, o[(b + 4 | 0) >> 2] = 0;
									break e;
								case 12:
									q = 0 | o[r >> 2], T = 0 | o[(A = v = (q + (8 - 1 | 0) | 0) & (-1 ^ (8 - 1 | 0))) >> 2], w = 0 | o[(A + 4 |
										0) >> 2], ue = v + 8 | 0, o[r >> 2] = ue, o[(E = e) >> 2] = T, o[(E + 4 | 0) >> 2] = w;
									break e;
								case 13:
									W = 0 | o[r >> 2], S = 0 | o[(M = (W + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], Q = M + 4 | 0, o[r >>
										2] = Q, R = ((0 | (k = (65535 & S) << 16 >> 16)) < 0) << 31 >> 31, o[(I = e) >> 2] = k, o[(I + 4 | 0) >>
										2] = R;
									break e;
								case 14:
									z = 0 | o[r >> 2], P = 0 | o[(O = (z + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], ee = O + 4 | 0, o[r >>
										2] = ee, u = 65535 & P, o[(B = e) >> 2] = u, o[(B + 4 | 0) >> 2] = 0;
									break e;
								case 15:
									V = 0 | o[r >> 2], L = 0 | o[(C = (V + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], te = C + 4 | 0, o[r >>
										2] = te, x = ((0 | (N = (255 & L) << 24 >> 24)) < 0) << 31 >> 31, o[(U = e) >> 2] = N, o[(U + 4 | 0) >>
										2] = x;
									break e;
								case 16:
									X = 0 | o[r >> 2], Y = 0 | o[(D = (X + (4 - 1 | 0) | 0) & (-1 ^ (4 - 1 | 0))) >> 2], re = D + 4 | 0, o[r >>
										2] = re, i = 255 & Y, o[(H = e) >> 2] = i, o[(H + 4 | 0) >> 2] = 0;
									break e;
								case 17:
									G = 0 | o[r >> 2], l = +a[(f = (G + (8 - 1 | 0) | 0) & (-1 ^ (8 - 1 | 0))) >> 3], ne = f + 8 | 0, o[r >> 2] =
										ne, a[e >> 3] = l;
									break e;
								case 18:
									J = 0 | o[r >> 2], d = +a[(c = (J + (8 - 1 | 0) | 0) & (-1 ^ (8 - 1 | 0))) >> 3], ie = c + 8 | 0, o[r >> 2] =
										ie, a[e >> 3] = d;
									break e;
								default:
									break e
							}
						}
					} while (0)
				}

				function ce(e, t, r, i) {
					r |= 0, i |= 0;
					var o = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						h = 0;
					if (0 == (0 | (e |= 0)) & 0 == (0 | (t |= 0))) o = r;
					else
						for (a = r, f = t, h = e;;) {
							if (u = 255 & (255 & (0 | n[(4052 + (15 & h) | 0) >> 0]) | i), n[(s = a + -1 | 0) >> 0] = u, 0 == (0 | (l = 0 |
									Se(0 | h, 0 | f, 4))) & 0 == (0 | (c = d))) {
								o = s;
								break
							}
							a = s, f = c, h = l
						}
					return 0 | o
				}

				function de(e, t, r) {
					r |= 0;
					var i = 0,
						o = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0;
					if (0 == (0 | (e |= 0)) & 0 == (0 | (t |= 0))) i = r;
					else
						for (o = r, u = t, l = e;;) {
							if (c = 48 | 7 & (255 & l), n[(a = o + -1 | 0) >> 0] = c, 0 == (0 | (s = 0 | Se(0 | l, 0 | u, 3))) & 0 == (0 |
									(f = d))) {
								i = a;
								break
							}
							o = a, u = f, l = s
						}
					return 0 | i
				}

				function he(e, t, r) {
					r |= 0;
					var i = 0,
						o = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0;
					if ((t |= 0) >>> 0 > 0 | 0 == (0 | t) & (e |= 0) >>> 0 > 4294967295) {
						for (u = r, g = e, b = t; l = 48 | 255 & (0 | Be(0 | g, 0 | b, 10, 0)), n[(c = u + -1 | 0) >> 0] = l, h = 0 |
							Oe(0 | g, 0 | b, 10, 0), p = d, b >>> 0 > 9 | 9 == (0 | b) & g >>> 0 > 4294967295;) u = c, g = h, b = p;
						i = h, a = c
					} else i = e, a = r;
					if (0 == (0 | i)) s = a;
					else
						for (o = i, f = a;;) {
							if (_ = 255 & (48 | (o >>> 0) % 10 & -1), n[(m = f + -1 | 0) >> 0] = _, y = (o >>> 0) / 10 & -1, o >>> 0 < 10) {
								s = m;
								break
							}
							o = y, f = m
						}
					return 0 | s
				}

				function pe(e, t, r, n, i) {
					e |= 0, t |= 0, r |= 0, n |= 0, i |= 0;
					var o, a, u = 0,
						s = 0,
						c = 0,
						d = 0,
						h = 0;
					if (a = f, (0 | (f = f + 256 | 0)) >= (0 | l) && g(256), o = a, (0 | r) > (0 | n) & 0 == (0 | 73728 & i)) {
						if (Me(0 | o, 0 | t, 0 | ((h = r - n | 0) >>> 0 < 256 ? h : 256)), h >>> 0 > 255) {
							for (c = r - n | 0, s = h; se(e, o, 256), (d = s + -256 | 0) >>> 0 > 255;) s = d;
							u = 255 & c
						} else u = h;
						se(e, o, u)
					}
					f = a
				}

				function _e(e, t) {
					return 0 | (0 == (0 | (e |= 0)) ? 0 : 0 | be(e, t |= 0))
				}

				function me(e, t, r, i, a, u) {
					e |= 0, t = +t, r |= 0, i |= 0, a |= 0, u |= 0;
					var s, c, p, _, m, y, b, v, A, T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						q = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						fe = 0,
						le = 0,
						ce = 0,
						de = 0,
						_e = 0,
						me = 0,
						be = 0,
						ve = 0,
						Ae = 0,
						Te = 0,
						we = 0,
						Se = 0,
						Re = 0,
						Ie = 0,
						Pe = 0,
						Ce = 0,
						Le = 0,
						Ne = 0,
						xe = 0,
						Ue = 0,
						Fe = 0,
						De = 0,
						Ye = 0,
						He = 0,
						je = 0,
						We = 0,
						ze = 0,
						Ve = 0,
						Ke = 0,
						Xe = 0,
						Ge = 0,
						Je = 0,
						$e = 0,
						qe = 0,
						Ze = 0,
						Qe = 0,
						et = 0,
						tt = 0,
						rt = 0,
						nt = 0,
						it = 0,
						ot = 0,
						at = 0,
						ut = 0,
						st = 0,
						ft = 0,
						lt = 0,
						ct = 0,
						dt = 0,
						ht = 0,
						pt = 0,
						_t = 0,
						mt = 0,
						yt = 0,
						gt = 0,
						bt = 0,
						vt = 0,
						At = 0,
						Tt = 0,
						wt = 0,
						Et = 0,
						Mt = 0,
						St = 0,
						kt = 0,
						Rt = 0,
						It = 0,
						Ot = 0,
						Pt = 0,
						Bt = 0,
						Ct = 0,
						Lt = 0,
						Nt = 0,
						xt = 0,
						Ut = 0,
						Ft = 0,
						Dt = 0,
						Yt = 0,
						Ht = 0,
						jt = 0,
						Wt = 0,
						zt = 0,
						Vt = 0,
						Kt = 0,
						Xt = 0,
						Gt = 0,
						Jt = 0,
						$t = 0,
						qt = 0,
						Zt = 0,
						Qt = 0,
						er = 0,
						tr = 0,
						rr = 0,
						nr = 0,
						ir = 0,
						or = 0,
						ar = 0,
						ur = 0,
						sr = 0,
						fr = 0,
						lr = 0,
						cr = 0,
						dr = 0,
						hr = 0,
						pr = 0,
						_r = 0,
						mr = 0,
						yr = 0,
						gr = 0,
						br = 0,
						vr = 0,
						Ar = 0,
						Tr = 0,
						wr = 0,
						Er = 0,
						Mr = 0,
						Sr = 0,
						kr = 0,
						Rr = 0,
						Ir = 0,
						Or = 0,
						Pr = 0,
						Br = 0,
						Cr = 0,
						Lr = 0,
						Nr = 0,
						xr = 0,
						Ur = 0,
						Fr = 0,
						Dr = 0,
						Yr = 0,
						Hr = 0,
						jr = 0,
						Wr = 0,
						zr = 0,
						Vr = 0,
						Kr = 0,
						Xr = 0,
						Gr = 0,
						Jr = 0,
						$r = 0,
						qr = 0,
						Zr = 0,
						Qr = 0,
						en = 0,
						tn = 0,
						rn = 0,
						nn = 0,
						on = 0,
						an = 0,
						un = 0,
						sn = 0,
						fn = 0,
						ln = 0,
						cn = 0,
						dn = 0,
						hn = 0,
						pn = 0,
						_n = 0,
						mn = 0,
						yn = 0,
						gn = 0,
						bn = 0,
						vn = 0,
						An = 0,
						Tn = 0,
						wn = 0,
						En = 0,
						Mn = 0,
						Sn = 0,
						kn = 0,
						Rn = 0,
						In = 0,
						On = 0,
						Pn = 0,
						Bn = 0,
						Cn = 0,
						Ln = 0,
						Nn = 0,
						xn = 0,
						Un = 0,
						Fn = 0,
						Dn = 0,
						Yn = 0,
						Hn = 0;
					A = f, (0 | (f = f + 560 | 0)) >= (0 | l) && g(560), m = A + 8 | 0, v = b = A + 524 | 0, s = A + 512 | 0, o[(y =
							A) >> 2] = 0, c = s + 12 | 0, ye(t), (0 | d) < 0 ? (O = -t, W = 1, z = 4017) : (O = t, W = 1 & 0 != (0 | 2049 &
							a), z = 0 == (0 | 2048 & a) ? 0 == (0 | 1 & a) ? 4018 : 4023 : 4020), ye(O), _ = (p = 2146435072 & d) >>> 0 <
						2146435072 | !1 & 2146435072 == (0 | p);
					do {
						if (_) {
							if ((hn = 0 != (on = 2 * +ge(O, y))) && (bn = (0 | o[y >> 2]) + -1 | 0, o[y >> 2] = bn), 97 == (0 | (vn = 32 |
									u))) {
								V = 0 == (0 | (An = 32 & u)) ? z : z + 9 | 0, Tn = 2 | W, En = i >>> 0 > 11 | 0 == (0 | (wn = 12 - i | 0));
								do {
									if (!En) {
										for (D = 8, ue = wn; Sn = 16 * D, !(0 == (0 | (Mn = ue + -1 | 0)));) D = Sn, ue = Mn;
										if ((0 | n[V >> 0]) << 24 >> 24 == 45) {
											ee = -(Sn + (-on - Sn));
											break
										}
										ee = on + Sn - Sn;
										break
									}
									ee = on
								} while (0);
								for ((0 | (In = 0 | he(Rn = (0 | (kn = 0 | o[y >> 2])) < 0 ? 0 - kn | 0 : kn, ((0 | Rn) < 0) << 31 >> 31, c))) ==
									(0 | c) ? (n[(On = s + 11 | 0) >> 0] = 48, H = On) : H = In, Pn = 255 & ((2 & kn >> 31) + 43 | 0), n[(H + -
										1 | 0) >> 0] = Pn, Bn = 255 & (u + 15 | 0), n[(Cn = H + -2 | 0) >> 0] = Bn, Hn = (0 | i) < 1, Ln = 0 == (0 |
										8 & a), K = b, Te = ee; xn = 255 & (255 & (0 | n[(4052 + (Nn = ~~Te) | 0) >> 0]) | An), Un = K + 1 | 0, n[
										K >> 0] = xn, Fn = 16 * (Te - +(0 | Nn)), 1 == (0 | (Un - v | 0)) ? Ln & (Hn & 0 == Fn) ? de = Un : (Dn =
										K + 2 | 0, n[Un >> 0] = 46, de = Dn) : de = Un, 0 != Fn;) K = de, Te = Fn;
								pe(e, 32, r, Et = ((wt = c - Cn | 0) + Tn | 0) + (_t = 0 != (0 | i) & (0 | ((Yn = de - v | 0) + -2 | 0)) < (
									0 | i) ? i + 2 | 0 : Yn) | 0, a), se(e, V, Tn), pe(e, 48, r, Et, 65536 ^ a), se(e, b, Yn), pe(e, 48, _t -
									Yn | 0, 0, 0), se(e, Cn, wt), pe(e, 32, r, Et, 8192 ^ a), Tt = Et;
								break
							}
							for (Je = (0 | i) < 0 ? 6 : i, hn ? (Mt = 268435456 * on, St = (0 | o[y >> 2]) + -28 | 0, o[y >> 2] = St, Ne =
									Mt, yt = St) : (Ne = on, yt = 0 | o[y >> 2]), F = it = (0 | yt) < 0 ? m : m + 288 | 0, je = Ne; kt = ~~je >>>
								0, o[F >> 2] = kt, Rt = F + 4 | 0, 0 != (It = 1e9 * (je - +(kt >>> 0)));) F = Rt, je = It;
							if ((0 | yt) > 0)
								for (ne = it, ae = Rt, Ot = yt;;) {
									if (Pt = (0 | Ot) < 29 ? Ot : 29, (L = ae + -4 | 0) >>> 0 < ne >>> 0) Se = ne;
									else {
										for (N = L, U = 0; Lt = 0 | Be(0 | (Bt = 0 | Ee(0 | (0 | ke(0 | (0 | o[N >> 2]), 0, 0 | Pt)), 0 | d, 0 | U,
												0)), 0 | (Ct = d), 1e9, 0), o[N >> 2] = Lt, Nt = 0 | Oe(0 | Bt, 0 | Ct, 1e9, 0), !((C = N + -4 | 0) >>>
												0 < ne >>> 0);) N = C, U = Nt;
										0 == (0 | Nt) ? Se = ne : (o[(xt = ne + -4 | 0) >> 2] = Nt, Se = xt)
									}
									for (Re = ae; Re >>> 0 > Se >>> 0 && 0 == (0 | (0 | o[(Ut = Re + -4 | 0) >> 2]));) Re = Ut;
									if (Ft = (0 | o[y >> 2]) - Pt | 0, o[y >> 2] = Ft, !((0 | Ft) > 0)) {
										re = Se, oe = Re, gt = Ft;
										break
									}
									ne = Se, ae = Re, Ot = Ft
								} else re = it, oe = Rt, gt = yt;
							if ((0 | gt) < 0)
								for (Dt = ((0 | (Je + 25 | 0)) / 9 & -1) + 1 | 0, Yt = 102 == (0 | vn), Fe = re, Ye = oe, jt = gt;;) {
									if (Wt = (0 | (Ht = 0 - jt | 0)) < 9 ? Ht : 9, Fe >>> 0 < Ye >>> 0) {
										for (zt = (1 << Wt) + -1 | 0, Vt = 1e9 >>> Wt, B = 0, ie = Fe; Xt = (Kt = 0 | o[ie >> 2]) & zt, Gt = (Kt >>>
												Wt) + B | 0, o[ie >> 2] = Gt, Jt = 0 | h(Xt, Vt), ($t = ie + 4 | 0) >>> 0 < Ye >>> 0;) B = Jt, ie = $t;
										T = 0 == (0 | (0 | o[Fe >> 2])) ? Fe + 4 | 0 : Fe, 0 == (0 | Jt) ? (w = T, Ke = Ye) : (qt = Ye + 4 | 0, o[
											Ye >> 2] = Jt, w = T, Ke = qt)
									} else w = 0 == (0 | (0 | o[Fe >> 2])) ? Fe + 4 | 0 : Fe, Ke = Ye;
									if (E = (0 | (Ke - (Zt = Yt ? it : w) | 0) >> 2) > (0 | Dt) ? Zt + (Dt << 2) | 0 : Ke, Qt = (0 | o[y >> 2]) +
										Wt | 0, o[y >> 2] = Qt, !((0 | Qt) < 0)) {
										Ue = w, De = E;
										break
									}
									Fe = w, Ye = E, jt = Qt
								} else Ue = re, De = oe;
							if (er = it, Ue >>> 0 < De >>> 0)
								if (tr = 9 * ((er - Ue | 0) >> 2) | 0, (rr = 0 | o[Ue >> 2]) >>> 0 < 10) ce = tr;
								else
									for (j = tr, $ = 10;;) {
										if (ir = j + 1 | 0, rr >>> 0 < (nr = 10 * $ | 0) >>> 0) {
											ce = ir;
											break
										}
										j = ir, $ = nr
									} else ce = 0;
							if ((0 | (ur = (Je - (102 != (0 | vn) ? ce : 0) | 0) + (((ar = 0 != (0 | Je)) & (or = 103 == (0 | vn))) << 31 >>
									31) | 0)) < (0 | ((9 * ((De - er | 0) >> 2) | 0) + -9 | 0))) {
								if (fr = (it + 4 | 0) + ((((0 | (sr = ur + 9216 | 0)) / 9 & -1) + -1024 | 0) << 2) | 0, (0 | (G = ((0 | sr) %
										9 & -1) + 1 | 0)) < 9)
									for (J = G, be = 10;;) {
										if (lr = 10 * be | 0, 9 == (0 | (X = J + 1 | 0))) {
											me = lr;
											break
										}
										J = X, be = lr
									} else me = 10;
								if ((hr = (0 | (fr + 4 | 0)) == (0 | De)) & 0 == (0 | (dr = ((cr = 0 | o[fr >> 2]) >>> 0) % (me >>> 0) & -1)))
									Ve = fr, Xe = ce, dt = Ue;
								else if (qe = 0 == (0 | 1 & ((cr >>> 0) / (me >>> 0) & -1)) ? 9007199254740992 : 9007199254740994, M = dr >>>
									0 < (pr = (0 | me) / 2 & -1) >>> 0 ? .5 : hr & (0 | dr) == (0 | pr) ? 1 : 1.5, 0 == (0 | W) ? (Z = M, Q =
										qe) : (Z = (_r = (0 | n[z >> 0]) << 24 >> 24 == 45) ? -M : M, Q = _r ? -qe : qe), mr = cr - dr | 0, o[fr >>
										2] = mr, Q + Z != Q) {
									if (yr = mr + me | 0, o[fr >> 2] = yr, yr >>> 0 > 999999999)
										for (tt = Ue, At = fr;;) {
											if (gr = At + -4 | 0, o[At >> 2] = 0, gr >>> 0 < tt >>> 0 ? (o[(br = tt + -4 | 0) >> 2] = 0, at = br) :
												at = tt, vr = (0 | o[gr >> 2]) + 1 | 0, o[gr >> 2] = vr, !(vr >>> 0 > 999999999)) {
												et = at, vt = gr;
												break
											}
											tt = at, At = gr
										} else et = Ue, vt = fr;
									if (Ar = 9 * ((er - et | 0) >> 2) | 0, (Tr = 0 | o[et >> 2]) >>> 0 < 10) Ve = vt, Xe = Ar, dt = et;
									else
										for (Pe = Ar, Le = 10;;) {
											if (Er = Pe + 1 | 0, Tr >>> 0 < (wr = 10 * Le | 0) >>> 0) {
												Ve = vt, Xe = Er, dt = et;
												break
											}
											Pe = Er, Le = wr
										}
								} else Ve = fr, Xe = ce, dt = Ue;
								nt = Xe, ct = De >>> 0 > (Mr = Ve + 4 | 0) >>> 0 ? Mr : De, ht = dt
							} else nt = ce, ct = De, ht = Ue;
							for (ft = ct;;) {
								if (!(ft >>> 0 > ht >>> 0)) {
									pt = 0;
									break
								}
								if (!(0 == (0 | (0 | o[(Sr = ft + -4 | 0) >> 2])))) {
									pt = 1;
									break
								}
								ft = Sr
							}
							kr = 0 - nt | 0;
							do {
								if (or) {
									if ((0 | ($e = (1 & (1 ^ ar)) + Je | 0)) > (0 | nt) & (0 | nt) > -5 ? (P = u + -1 | 0, we = ($e + -1 | 0) -
											nt | 0) : (P = u + -2 | 0, we = $e + -1 | 0), 0 == (0 | (Rr = 8 & a))) {
										if (pt)
											if (0 == (0 | (Ir = 0 | o[(ft + -4 | 0) >> 2]))) Ce = 9;
											else if (0 == (0 | (Ir >>> 0) % 10 & -1))
											for (_e = 0, He = 10;;) {
												if (Pr = _e + 1 | 0, !(0 == (0 | (Ir >>> 0) % ((Or = 10 * He | 0) >>> 0) & -1))) {
													Ce = Pr;
													break
												}
												_e = Pr, He = Or
											} else Ce = 0;
										else Ce = 9;
										if (Cr = (9 * ((ft - er | 0) >> 2) | 0) + -9 | 0, 102 == (0 | (32 | P))) {
											te = P, xe = (0 | we) < (0 | (Ze = (0 | (Lr = Cr - Ce | 0)) > 0 ? Lr : 0)) ? we : Ze, bt = 0;
											break
										}
										te = P, xe = (0 | we) < (0 | (Qe = (0 | (Nr = (Cr + nt | 0) - Ce | 0)) > 0 ? Nr : 0)) ? we : Qe, bt = 0;
										break
									}
									te = P, xe = we, bt = Rr
								} else te = u, xe = Je, bt = 8 & a
							} while (0);
							if (Ur = 1 & 0 != (0 | (xr = xe | bt)), Fr = 102 == (0 | (32 | te))) Ie = 0, mt = (0 | nt) > 0 ? nt : 0;
							else {
								if ((0 | ((Hr = c) - (Yr = 0 | he(Dr = (0 | nt) < 0 ? kr : nt, ((0 | Dr) < 0) << 31 >> 31, c)) | 0)) < 2)
									for (le = Yr;;) {
										if (n[(jr = le + -1 | 0) >> 0] = 48, !((0 | (Hr - jr | 0)) < 2)) {
											fe = jr;
											break
										}
										le = jr
									} else fe = Yr;
								Wr = 255 & ((2 & nt >> 31) + 43 | 0), n[(fe + -1 | 0) >> 0] = Wr, zr = 255 & te, n[(Vr = fe + -2 | 0) >> 0] =
									zr, Ie = Vr, mt = Hr - Vr | 0
							}
							if (pe(e, 32, r, Xr = (((W + 1 | 0) + xe | 0) + Ur | 0) + mt | 0, a), se(e, z, W), pe(e, 48, r, Xr, 65536 ^ a),
								Fr) {
								for (Jr = Gr = b + 9 | 0, $r = b + 8 | 0, rt = x = ht >>> 0 > it >>> 0 ? it : ht;;) {
									if (qr = 0 | he(0 | o[rt >> 2], 0, Gr), (0 | rt) == (0 | x))(0 | qr) == (0 | Gr) ? (n[$r >> 0] = 48, q = $r) :
										q = qr;
									else if (qr >>> 0 > b >>> 0)
										for (Me(0 | b, 48, 0 | (qr - v | 0)), I = qr;;) {
											if (!((Zr = I + -1 | 0) >>> 0 > b >>> 0)) {
												q = Zr;
												break
											}
											I = Zr
										} else q = qr;
									if (se(e, q, Jr - q | 0), (Qr = rt + 4 | 0) >>> 0 > it >>> 0) break;
									rt = Qr
								}
								if (0 == (0 | xr) || se(e, 4068, 1), Qr >>> 0 < ft >>> 0 & (0 | xe) > 0)
									for (ze = xe, ut = Qr;;) {
										if ((en = 0 | he(0 | o[ut >> 2], 0, Gr)) >>> 0 > b >>> 0)
											for (Me(0 | b, 48, 0 | (en - v | 0)), R = en;;) {
												if (!((tn = R + -1 | 0) >>> 0 > b >>> 0)) {
													k = tn;
													break
												}
												R = tn
											} else k = en;
										if (se(e, k, (0 | ze) < 9 ? ze : 9), nn = ze + -9 | 0, !((rn = ut + 4 | 0) >>> 0 < ft >>> 0 & (0 | ze) > 9)) {
											We = nn;
											break
										}
										ze = nn, ut = rn
									} else We = xe;
								pe(e, 48, We + 9 | 0, 9, 0)
							} else {
								if (lt = pt ? ft : ht + 4 | 0, (0 | xe) > -1)
									for (un = 0 == (0 | bt), sn = an = b + 9 | 0, fn = 0 - v | 0, ln = b + 8 | 0, ot = xe, st = ht;;) {
										(0 | (cn = 0 | he(0 | o[st >> 2], 0, an))) == (0 | an) ? (n[ln >> 0] = 48, S = ln) : S = cn, dn = (0 | st) ==
											(0 | ht);
										do {
											if (dn) {
												if (_n = S + 1 | 0, se(e, S, 1), un & (0 | ot) < 1) {
													Ae = _n;
													break
												}
												se(e, 4068, 1), Ae = _n
											} else {
												if (!(S >>> 0 > b >>> 0)) {
													Ae = S;
													break
												}
												for (Me(0 | b, 48, 0 | (S + fn | 0)), ve = S;;) {
													if (!((pn = ve + -1 | 0) >>> 0 > b >>> 0)) {
														Ae = pn;
														break
													}
													ve = pn
												}
											}
										} while (0);
										if (se(e, Ae, (0 | ot) > (0 | (mn = sn - Ae | 0)) ? mn : ot), !((gn = st + 4 | 0) >>> 0 < lt >>> 0 & (0 |
												(yn = ot - mn | 0)) > -1)) {
											Ge = yn;
											break
										}
										ot = yn, st = gn
									} else Ge = xe;
								pe(e, 48, Ge + 18 | 0, 18, 0), se(e, Ie, c - Ie | 0)
							}
							pe(e, 32, r, Xr, 8192 ^ a), Tt = Xr
						} else Br = 0 != (0 | 32 & u), Y = O != O | !1 ? Br ? 4044 : 4048 : Br ? 4036 : 4040, pe(e, 32, r, Kr = W + 3 |
							0, -65537 & a), se(e, z, W), se(e, Y, 3), pe(e, 32, r, Kr, 8192 ^ a), Tt = Kr
					} while (0);
					return f = A, 0 | ((0 | Tt) < (0 | r) ? r : Tt)
				}

				function ye(e) {
					e = +e;
					var t, r;
					return a[s >> 3] = e, t = 0 | o[s >> 2], r = 0 | o[s + 4 >> 2], d = r, 0 | t
				}

				function ge(e, t) {
					return + + function e(t, r) {
						t = +t;
						r |= 0;
						var n = 0,
							i = 0,
							u = 0,
							f = 0,
							l = 0,
							c = 0,
							d = 0,
							h = 0,
							p = 0,
							_ = 0,
							m = 0,
							y = 0,
							g = 0;
						a[s >> 3] = t;
						d = 0 | o[s >> 2];
						h = 0 | o[s + 4 >> 2];
						p = 0 | Se(0 | d, 0 | h, 52);
						_ = 65535 & p;
						g = 2047 & _;
						switch (g << 16 >> 16) {
							case 0:
								0 != t ? (m = +e(0x10000000000000000 * t, r), u = 0 | o[r >> 2], i = m, y = u + -64 | 0) : (i = t, y = 0),
									o[r >> 2] = y, n = i;
								break;
							case 2047:
								n = t;
								break;
							default:
								f = (2047 & p) + -1022 | 0, o[r >> 2] = f, l = 1071644672 | -2146435073 & h, o[s >> 2] = d, o[s + 4 >> 2] =
									l, c = +a[s >> 3], n = c
						}
						return +n
					}(e = +e, t |= 0)
				}

				function be(e, t, r) {
					t |= 0;
					var i, a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0;
					i = 0 == (0 | (e |= 0));
					do {
						if (!i) {
							if (t >>> 0 < 128) {
								A = 255 & t, n[e >> 0] = A, a = 1;
								break
							}
							if (S = 0 | ve(), k = 0 | o[(S + 188 | 0) >> 2], 0 == (0 | (0 | o[k >> 2]))) {
								if (57216 == (0 | -128 & t)) {
									s = 255 & t, n[e >> 0] = s, a = 1;
									break
								}
								u = 0 | q(), o[u >> 2] = 84, a = -1;
								break
							}
							if (t >>> 0 < 2048) {
								f = 255 & (192 | t >>> 6), l = e + 1 | 0, n[e >> 0] = f, c = 255 & (128 | 63 & t), n[l >> 0] = c, a = 2;
								break
							}
							if (t >>> 0 < 55296 | 57344 == (0 | -8192 & t)) {
								d = 255 & (224 | t >>> 12), h = e + 1 | 0, n[e >> 0] = d, p = 255 & (128 | 63 & t >>> 6), _ = e + 2 | 0, n[h >>
									0] = p, m = 255 & (128 | 63 & t), n[_ >> 0] = m, a = 3;
								break
							}
							if ((t + -65536 | 0) >>> 0 < 1048576) {
								y = 255 & (240 | t >>> 18), g = e + 1 | 0, n[e >> 0] = y, b = 255 & (128 | 63 & t >>> 12), v = e + 2 | 0, n[
									g >> 0] = b, T = 255 & (128 | 63 & t >>> 6), w = e + 3 | 0, n[v >> 0] = T, E = 255 & (128 | 63 & t), n[w >>
									0] = E, a = 4;
								break
							}
							M = 0 | q(), o[M >> 2] = 84, a = -1;
							break
						}
						a = 1
					} while (0);
					return 0 | a
				}

				function ve() {
					return 8, 8
				}

				function Ae(e, t, r) {
					e |= 0, t |= 0;
					var i, a, u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0,
						h = 0,
						p = 0,
						_ = 0,
						m = 0,
						y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0;
					0 == (0 | (a = 0 | o[(i = (r |= 0) + 16 | 0) >> 2])) ? 0 == (0 | (0 | function(e) {
						var t = 0,
							r = 0,
							i = 0,
							a = 0,
							u = 0,
							s = 0,
							f = 0,
							l = 0,
							c = 0,
							d = 0;
						f = 0 | n[(r = 74 + (e |= 0) | 0) >> 0], c = 255 & (255 + (l = f << 24 >> 24) | 0 | l), n[r >> 0] = c, d =
							0 | o[e >> 2], 0 == (0 | 8 & d) ? (o[(e + 8 | 0) >> 2] = 0, o[(e + 4 | 0) >> 2] = 0, a = 0 | o[(e + 44 | 0) >>
								2], o[(e + 28 | 0) >> 2] = a, o[(e + 20 | 0) >> 2] = a, u = 0 | o[(e + 48 | 0) >> 2], s = a + u | 0, o[(
								e + 16 | 0) >> 2] = s, t = 0) : (i = 32 | d, o[e >> 2] = i, t = -1);
						return 0 | t
					}(r))) ? (h = 0 | o[i >> 2], w = 5) : s = 0 : (h = a, w = 5);
					e: do {
						if (5 == (0 | w)) {
							if (p = d = 0 | o[(T = r + 20 | 0) >> 2], (h - d | 0) >>> 0 < t >>> 0) {
								_ = 0 | o[(r + 36 | 0) >> 2], s = 0 | Ue[7 & _](r, e, t);
								break
							}
							m = (0 | n[(r + 75 | 0) >> 0]) << 24 >> 24 > -1;
							t: do {
								if (m) {
									for (u = t;;) {
										if (0 == (0 | u)) {
											f = 0, l = e, c = t, v = p;
											break t
										}
										if ((0 | n[(e + (y = u + -1 | 0) | 0) >> 0]) << 24 >> 24 == 10) break;
										u = y
									}
									if (g = 0 | o[(r + 36 | 0) >> 2], (b = 0 | Ue[7 & g](r, e, u)) >>> 0 < u >>> 0) {
										s = b;
										break e
									}
									f = u, l = e + u | 0, c = t - u | 0, v = 0 | o[T >> 2]
								} else f = 0, l = e, c = t, v = p
							} while (0);
							Ce(0 | v, 0 | l, 0 | c), A = (0 | o[T >> 2]) + c | 0, o[T >> 2] = A, s = f + c | 0
						}
					} while (0);
					return 0 | s
				}

				function Te(e) {
					var t, r, n = 0,
						i = 0,
						a = 0,
						u = 0,
						s = 0,
						f = 0,
						l = 0,
						c = 0,
						d = 0;
					return (0 | o[(t = (e |= 0) + 20 | 0) >> 2]) >>> 0 > (0 | o[(r = e + 28 | 0) >> 2]) >>> 0 ? (c = 0 | o[(e + 36 |
						0) >> 2], Ue[7 & c](e, 0, 0), 0 == (0 | (0 | o[t >> 2])) ? n = -1 : d = 3) : d = 3, 3 == (0 | d) && ((a = 0 |
						o[(i = e + 4 | 0) >> 2]) >>> 0 < (s = 0 | o[(u = e + 8 | 0) >> 2]) >>> 0 && (f = a - s | 0, l = 0 | o[(e +
						40 | 0) >> 2], Ue[7 & l](e, f, 1)), o[(e + 16 | 0) >> 2] = 0, o[r >> 2] = 0, o[t >> 2] = 0, o[u >> 2] = 0, o[
						i >> 2] = 0, n = 0), 0 | n
				}

				function we(e, t, r, n) {
					return (t |= 0) - (n |= 0) >>> 0, 0 | (d = t - n - ((r |= 0) >>> 0 > (e |= 0) >>> 0 | 0) >>> 0, 0 | e - r >>>
						0)
				}

				function Ee(e, t, r, n) {
					var i;
					return 0 | (d = (t |= 0) + (n |= 0) + ((i = (e |= 0) + (r |= 0) >>> 0) >>> 0 < e >>> 0 | 0) >>> 0, 0 | i)
				}

				function Me(e, t, r) {
					t |= 0;
					var i, a = 0,
						u = 0,
						s = 0;
					if (i = (e |= 0) + (r |= 0) | 0, t &= 255, (0 | r) >= 67) {
						for (; 0 != (3 & e);) n[e >> 0] = t, e = e + 1 | 0;
						for (u = (a = -4 & i | 0) - 64 | 0, s = t | t << 8 | t << 16 | t << 24;
							(0 | e) <= (0 | u);) o[e >> 2] = s, o[e + 4 >> 2] = s, o[e + 8 >> 2] = s, o[e + 12 >> 2] = s, o[e + 16 >> 2] =
							s, o[e + 20 >> 2] = s, o[e + 24 >> 2] = s, o[e + 28 >> 2] = s, o[e + 32 >> 2] = s, o[e + 36 >> 2] = s, o[e +
								40 >> 2] = s, o[e + 44 >> 2] = s, o[e + 48 >> 2] = s, o[e + 52 >> 2] = s, o[e + 56 >> 2] = s, o[e + 60 >> 2] =
							s, e = e + 64 | 0;
						for (;
							(0 | e) < (0 | a);) o[e >> 2] = s, e = e + 4 | 0
					}
					for (;
						(0 | e) < (0 | i);) n[e >> 0] = t, e = e + 1 | 0;
					return i - r | 0
				}

				function Se(e, t, r) {
					t |= 0;
					return (0 | (r |= 0)) < 32 ? (d = t >>> r, (e |= 0) >>> r | (t & ((1 << r) - 1 | 0)) << 32 - r) : (d = 0, t >>>
						r - 32 | 0)
				}

				function ke(e, t, r) {
					e |= 0;
					return (0 | (r |= 0)) < 32 ? (d = (t |= 0) << r | (e & ((1 << r) - 1 | 0) << 32 - r) >>> 32 - r, e << r) : (d =
						e << r - 32, 0)
				}

				function Re(e) {
					var t = 0;
					return (0 | (t = 0 | n[c + (255 & (e |= 0)) >> 0])) < 8 ? 0 | t : (0 | (t = 0 | n[c + (e >> 8 & 255) >> 0])) <
						8 ? t + 8 | 0 : (0 | (t = 0 | n[c + (e >> 16 & 255) >> 0])) < 8 ? t + 16 | 0 : 24 + (0 | n[c + (e >>> 24) >> 0]) |
						0
				}

				function Ie(e, t, r, n, i) {
					i |= 0;
					var a, u, s, f, l, c, h, _, m, y = 0,
						g = 0,
						b = 0,
						v = 0,
						A = 0,
						T = 0,
						w = 0,
						E = 0,
						M = 0,
						S = 0,
						k = 0,
						R = 0,
						I = 0,
						O = 0,
						P = 0,
						B = 0,
						C = 0,
						L = 0,
						N = 0,
						x = 0,
						U = 0,
						F = 0,
						D = 0,
						Y = 0,
						H = 0,
						j = 0,
						W = 0,
						z = 0,
						V = 0,
						K = 0,
						X = 0,
						G = 0,
						J = 0,
						$ = 0,
						q = 0,
						Z = 0,
						Q = 0,
						ee = 0,
						te = 0,
						re = 0,
						ne = 0,
						ie = 0,
						oe = 0,
						ae = 0,
						ue = 0,
						se = 0,
						fe = 0,
						le = 0,
						ce = 0,
						de = 0;
					if (a = e |= 0, f = r |= 0, c = l = n |= 0, 0 == (0 | (s = u = t |= 0))) return y = 0 != (0 | i), 0 == (0 | c) ?
						(y && (o[i >> 2] = (a >>> 0) % (f >>> 0), o[i + 4 >> 2] = 0), 0 | (d = de = 0, ce = (a >>> 0) / (f >>> 0) >>>
							0)) : y ? (o[i >> 2] = -1 & e, o[i + 4 >> 2] = 0 & t, 0 | (d = de = 0, ce = 0)) : 0 | (d = de = 0, ce = 0);
					h = 0 == (0 | c);
					do {
						if (0 == (0 | f)) {
							if (h) return 0 != (0 | i) && (o[i >> 2] = (s >>> 0) % (f >>> 0), o[i + 4 >> 2] = 0), 0 | (d = de = 0, ce = (
								s >>> 0) / (f >>> 0) >>> 0);
							if (0 == (0 | a)) return 0 != (0 | i) && (o[i >> 2] = 0, o[i + 4 >> 2] = (s >>> 0) % (c >>> 0)), 0 | (d = de =
								0, ce = (s >>> 0) / (c >>> 0) >>> 0);
							if (0 == ((g = c - 1 | 0) & c | 0)) return 0 != (0 | i) && (o[i >> 2] = 0 | -1 & e, o[i + 4 >> 2] = g & s | 0 &
								t), de = 0, ce = s >>> ((0 | Re(0 | c)) >>> 0), 0 | (d = de, ce);
							if ((b = (0 | p(0 | c)) - (0 | p(0 | s)) | 0) >>> 0 <= 30) {
								F = v = b + 1 | 0, U = s << (A = 31 - b | 0) | a >>> (v >>> 0), x = s >>> (v >>> 0), N = 0, L = a << A;
								break
							}
							return 0 == (0 | i) ? 0 | (d = de = 0, ce = 0) : (o[i >> 2] = 0 | -1 & e, o[i + 4 >> 2] = u | 0 & t, 0 | (d =
								de = 0, ce = 0))
						}
						if (!h) {
							if ((O = (0 | p(0 | c)) - (0 | p(0 | s)) | 0) >>> 0 <= 31) {
								F = P = O + 1 | 0, U = a >>> (P >>> 0) & (C = O - 31 >> 31) | s << (B = 31 - O | 0), x = s >>> (P >>> 0) & C,
									N = 0, L = a << B;
								break
							}
							return 0 == (0 | i) ? 0 | (d = de = 0, ce = 0) : (o[i >> 2] = 0 | -1 & e, o[i + 4 >> 2] = u | 0 & t, 0 | (d =
								de = 0, ce = 0))
						}
						if (0 != ((T = f - 1 | 0) & f | 0)) {
							F = E = (33 + (0 | p(0 | f)) | 0) - (0 | p(0 | s)) | 0, U = (S = 32 - E | 0) - 1 >> 31 & s >>> ((R = E - 32 |
									0) >>> 0) | (s << S | a >>> (E >>> 0)) & (I = R >> 31), x = I & s >>> (E >>> 0), N = a << (M = 64 - E | 0) &
								(k = S >> 31), L = (s << M | a >>> (R >>> 0)) & k | a << S & E - 33 >> 31;
							break
						}
						return 0 != (0 | i) && (o[i >> 2] = T & a, o[i + 4 >> 2] = 0), 1 == (0 | f) ? 0 | (d = de = u | 0 & t, ce = 0 |
							-1 & e) : (w = 0 | Re(0 | f), 0 | (d = de = 0 | s >>> (w >>> 0), ce = s << 32 - w | a >>> (w >>> 0) | 0))
					} while (0);
					if (0 == (0 | F)) le = L, fe = N, se = x, ue = U, ae = 0, oe = 0;
					else {
						for (H = 0 | Ee(0 | (D = 0 | -1 & r), 0 | (Y = l | 0 & n), -1, -1), j = d, G = L, X = N, K = x, V = U, z = F,
							W = 0; J = X >>> 31 | G << 1, $ = W | X << 1, we(0 | H, 0 | j, 0 | (q = V << 1 | G >>> 31 | 0), 0 | (Z = V >>>
								31 | K << 1 | 0)), te = 1 & (ee = (Q = d) >> 31 | ((0 | Q) < 0 ? -1 : 0) << 1), re = 0 | we(0 | q, 0 | Z, ee &
								D | 0, (((0 | Q) < 0 ? -1 : 0) >> 31 | ((0 | Q) < 0 ? -1 : 0) << 1) & Y | 0), ne = d, 0 != (0 | (ie = z - 1 |
								0));) G = J, X = $, K = ne, V = re, z = ie, W = te;
						le = J, fe = $, se = ne, ue = re, ae = 0, oe = te
					}
					return _ = fe, 0, m = 0 | le, 0 != (0 | i) && (o[i >> 2] = 0 | ue, o[i + 4 >> 2] = 0 | se), 0 | (d = de = (0 |
						_) >>> 31 | m << 1 | 0 & (0 | _ >>> 31) | ae, ce = -2 & (_ << 1 | 0) | oe)
				}

				function Oe(e, t, r, n) {
					return 0 | (0 | Ie(e |= 0, t |= 0, r |= 0, n |= 0, 0))
				}

				function Pe(e) {
					var t, r;
					return (0 | (e = (e |= 0) + 15 & -16 | 0)) > 0 & (0 | (r = (t = 0 | o[u >> 2]) + e | 0)) < (0 | t) | (0 | r) <
						0 ? (y(), w(12), -1) : (o[u >> 2] = r, (0 | r) > (0 | (0 | m())) && 0 == (0 | _()) ? (o[u >> 2] = t, w(12), -1) :
							0 | t)
				}

				function Be(e, t, r, n) {
					var i, a;
					return a = f, f = f + 16 | 0, Ie(e |= 0, t |= 0, r |= 0, n |= 0, i = 0 | a), f = a, 0 | (d = 0 | o[i + 4 >> 2],
						0 | o[i >> 2])
				}

				function Ce(e, t, r) {
					e |= 0, t |= 0;
					var i, a, u = 0,
						s = 0;
					if ((0 | (r |= 0)) >= 8192) return 0 | M(0 | e, 0 | t, 0 | r);
					if (i = 0 | e, a = e + r | 0, (3 & e) == (3 & t)) {
						for (; 3 & e;) {
							if (0 == (0 | r)) return 0 | i;
							n[e >> 0] = 0 | n[t >> 0], e = e + 1 | 0, t = t + 1 | 0, r = r - 1 | 0
						}
						for (s = (u = -4 & a | 0) - 64 | 0;
							(0 | e) <= (0 | s);) o[e >> 2] = 0 | o[t >> 2], o[e + 4 >> 2] = 0 | o[t + 4 >> 2], o[e + 8 >> 2] = 0 | o[t +
							8 >> 2], o[e + 12 >> 2] = 0 | o[t + 12 >> 2], o[e + 16 >> 2] = 0 | o[t + 16 >> 2], o[e + 20 >> 2] = 0 | o[t +
							20 >> 2], o[e + 24 >> 2] = 0 | o[t + 24 >> 2], o[e + 28 >> 2] = 0 | o[t + 28 >> 2], o[e + 32 >> 2] = 0 | o[t +
							32 >> 2], o[e + 36 >> 2] = 0 | o[t + 36 >> 2], o[e + 40 >> 2] = 0 | o[t + 40 >> 2], o[e + 44 >> 2] = 0 | o[t +
							44 >> 2], o[e + 48 >> 2] = 0 | o[t + 48 >> 2], o[e + 52 >> 2] = 0 | o[t + 52 >> 2], o[e + 56 >> 2] = 0 | o[t +
							56 >> 2], o[e + 60 >> 2] = 0 | o[t + 60 >> 2], e = e + 64 | 0, t = t + 64 | 0;
						for (;
							(0 | e) < (0 | u);) o[e >> 2] = 0 | o[t >> 2], e = e + 4 | 0, t = t + 4 | 0
					} else
						for (u = a - 4 | 0;
							(0 | e) < (0 | u);) n[e >> 0] = 0 | n[t >> 0], n[e + 1 >> 0] = 0 | n[t + 1 >> 0], n[e + 2 >> 0] = 0 | n[t + 2 >>
							0], n[e + 3 >> 0] = 0 | n[t + 3 >> 0], e = e + 4 | 0, t = t + 4 | 0;
					for (;
						(0 | e) < (0 | a);) n[e >> 0] = 0 | n[t >> 0], e = e + 1 | 0, t = t + 1 | 0;
					return 0 | i
				}

				function Le(e) {
					return (255 & (e |= 0)) << 24 | (e >> 8 & 255) << 16 | (e >> 16 & 255) << 8 | e >>> 24 | 0
				}

				function Ne(e, t, r) {
					return v(1), 0
				}
				var xe = [function(e) {
						return b(0), 0
					}, function(e) {
						var t, r, n, i;
						return e |= 0, i = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), n = i, t = 0 | function(e) {
							return 0 | (e |= 0)
						}(0 | o[(e + 60 | 0) >> 2]), o[n >> 2] = t, r = 0 | $(0 | T(6, 0 | n)), f = i, 0 | r
					}],
					Ue = [Ne, Ne, function(e, t, r) {
						e |= 0, t |= 0, r |= 0;
						var i, a, u, s, c = 0,
							d = 0;
						return s = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), u = s, a = s + 16 | 0, o[(e + 36 | 0) >> 2] = 5, 0 ==
							(0 | 64 & (0 | o[e >> 2])) && (d = 0 | o[(e + 60 | 0) >> 2], c = a, o[u >> 2] = d, o[(u + 4 | 0) >> 2] =
								21523, o[(u + 8 | 0) >> 2] = c, 0 == (0 | S(54, 0 | u)) || (n[(e + 75 | 0) >> 0] = -1)), i = 0 | J(e, t, r),
							f = s, 0 | i
					}, function(e, t, r) {
						e |= 0, t |= 0, r |= 0;
						var n, i, a, u, s, c = 0;
						return s = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), u = s, n = s + 20 | 0, i = 0 | o[(e + 60 | 0) >> 2],
							a = n, o[u >> 2] = i, o[(u + 4 | 0) >> 2] = 0, o[(u + 8 | 0) >> 2] = t, o[(u + 12 | 0) >> 2] = a, o[(u + 16 |
								0) >> 2] = r, (0 | $(0 | E(140, 0 | u))) < 0 ? (o[n >> 2] = -1, c = -1) : c = 0 | o[n >> 2], f = s, 0 | c
					}, function(e, t, r) {
						var n, i, a, u, s, f;
						return t |= 0, r |= 0, a = 0 | o[(16 + (e |= 0) | 0) >> 2], Ce(0 | (s = 0 | o[(u = e + 20 | 0) >> 2]), 0 | t,
							0 | (n = (f = a - s | 0) >>> 0 > r >>> 0 ? r : f)), i = (0 | o[u >> 2]) + n | 0, o[u >> 2] = i, 0 | r
					}, J, Ne, Ne];
				return {
					_llvm_bswap_i32: Le,
					_loadtoken: function(e) {
						e |= 0;
						var t, r, i, a, u, s, c, d, h, p, _, m, y = 0,
							b = 0,
							v = 0,
							A = 0,
							T = 0,
							w = 0;
						m = f, (0 | (f = f + 80 | 0)) >= (0 | l) && g(80), u = m + 40 | 0, t = m + 4 | 0, i = e, T = 1612, w = 16 + (
							A = a = m + 56 | 0) | 0;
						do {
							n[A >> 0] = 0 | n[T >> 0], A = A + 1 | 0, T = T + 1 | 0
						} while ((0 | A) < (0 | w));
						T = 1628, w = (A = u) + 16 | 0;
						do {
							n[A >> 0] = 0 | n[T >> 0], A = A + 1 | 0, T = T + 1 | 0
						} while ((0 | A) < (0 | w));
						if (0 == (0 | (d = 0 | X(s = 0 | Z(i))))) return f = m, 4832;
						if (function(e, t, r) {
								e |= 0, t |= 0, r |= 0;
								var i, o, a, u, s = 0,
									c = 0,
									d = 0,
									h = 0,
									p = 0,
									_ = 0;
								for (u = f, (0 | (f = f + 32 | 0)) >= (0 | l) && g(32), i = e, o = t, a = r, h = 0;
									(0 | h) < (0 | a);) s = 255 & (p = 0 | K(0 | n[(o + h | 0) >> 0])), c = 255 & (_ = 0 | K(0 | n[(o + (h + 1 |
									0) | 0) >> 0])), d = 255 & ((255 & (p = (0 | 255 & p) > 57 ? 255 & (s - 55 | 0) : 255 & (s - 48 | 0))) <<
									4 | 255 & (_ = (0 | 255 & _) > 57 ? 255 & (c - 55 | 0) : 255 & (c - 48 | 0))), n[(i + ((0 | h) / 2 & -1) |
									0) >> 0] = d, h = h + 2 | 0;
								f = u
							}(d, i, s), 0 == (0 | (h = 0 | X(s)))) return f = m, 4832;
						for (p = a, _ = u, y = 0;
							(0 | y) < 16;) b = 255 & (82 ^ 255 & (0 | n[(a + y | 0) >> 0])), n[(p + y | 0) >> 0] = b, v = 255 & (82 ^
							255 & (0 | n[(u + y | 0) >> 0])), n[(_ + y | 0) >> 0] = v, y = y + 1 | 0;
						return C(h, d, s, p, _), o[t >> 2] = 0, c = 0 | function(e, t, r) {
							e |= 0, t |= 0, r |= 0;
							var i, a, u, s, c, d, h = 0,
								p = 0,
								_ = 0,
								m = 0,
								y = 0,
								b = 0,
								v = 0,
								A = 0,
								T = 0,
								w = 0,
								E = 0,
								M = 0,
								S = 0,
								k = 0,
								R = 0,
								I = 0,
								O = 0,
								P = 0,
								B = 0,
								C = 0,
								L = 0,
								N = 0,
								x = 0,
								U = 0,
								F = 0,
								D = 0,
								Y = 0,
								H = 0,
								j = 0,
								W = 0,
								z = 0,
								V = 0,
								K = 0;
							if (d = f, (0 | (f = f + 80 | 0)) >= (0 | l) && g(80), u = r, s = e, z = 0, b = 0, (0 | (a = t)) < 2) return o[
								u >> 2] = 0, f = d, 0;
							if (61 == (0 | 255 & (0 | n[(s + (a - 1 | 0) | 0) >> 0])) && (b = b + 1 | 0), 61 == (0 | 255 & (0 | n[(s +
									(a - 2 | 0) | 0) >> 0])) && (b = b + 1 | 0), i = ((0 | 3 * a) / 4 & -1) - b | 0, o[u >> 2] = i, 0 == (0 |
									(c = 0 | X(0 | o[u >> 2])))) return f = d, 0;
							for (_ = 0;
								(0 | _) <= (0 | (a - 4 | 0) - b);) H = 0 | n[(s + _ | 0) >> 0], w = 255 & (0 | n[(1335 + (255 & H) | 0) >>
									0]), j = 0 | n[(s + (_ + 1 | 0) | 0) >> 0], M = 255 & (0 | n[(1335 + (255 & j) | 0) >> 0]), W = 0 | n[(s +
									(_ + 2 | 0) | 0) >> 0], k = 255 & (0 | n[(1335 + (255 & W) | 0) >> 0]), V = 0 | n[(s + (_ + 3 | 0) | 0) >>
									0], O = 255 & (0 | n[(1335 + (255 & V) | 0) >> 0]), m = 255 & (w << 2 | M >> 4), z = (y = z) + 1 | 0, n[(
									c + y | 0) >> 0] = m, v = 255 & (M << 4 | k >> 2), z = (A = z) + 1 | 0, n[(c + A | 0) >> 0] = v, T = 255 &
								(k << 6 | O), z = (E = z) + 1 | 0, n[(c + E | 0) >> 0] = T, _ = _ + 4 | 0;
							return 1 == (0 | b) ? (S = 0 | n[(s + _ | 0) >> 0], B = 255 & (0 | n[(1335 + (255 & S) | 0) >> 0]), R = 0 |
									n[(s + (_ + 1 | 0) | 0) >> 0], L = 255 & (0 | n[(1335 + (255 & R) | 0) >> 0]), I = 0 | n[(s + (_ + 2 | 0) |
										0) >> 0], U = 255 & (0 | n[(1335 + (255 & I) | 0) >> 0]), P = 255 & (B << 2 | L >> 4), z = (C = z) + 1 |
									0, n[(c + C | 0) >> 0] = P, z = (N = z) + 1 | 0, h = 255 & (L << 4 | U >> 2), p = c + N | 0, K = 16) : 2 ==
								(0 | b) && (x = 0 | n[(s + _ | 0) >> 0], D = 255 & (0 | n[(1335 + (255 & x) | 0) >> 0]), F = 0 | n[(s + (_ +
									1 | 0) | 0) >> 0], z = (Y = z) + 1 | 0, h = 255 & (D << 2 | (255 & (0 | n[(1335 + (255 & F) | 0) >> 0])) >>
									4), p = c + Y | 0, K = 16), 16 == (0 | K) && (n[p >> 0] = h), f = d, 0 | c
						}(h, s, t), r = c, G(h), G(d), f = m, 0 | r
					},
					_i64Subtract: we,
					___udivdi3: Oe,
					setThrew: function(e, t) {},
					_bitshift64Lshr: Se,
					_bitshift64Shl: ke,
					_fflush: function e(t) {
						var r, n = 0,
							i = 0,
							a = 0,
							u = 0,
							s = 0,
							f = 0,
							l = 0,
							c = 0,
							d = 0;
						r = 0 == (0 | (t |= 0));
						do {
							if (r) {
								if (d = 0 == (0 | o[94]) ? 0 : 0 | e(0 | o[94]), c = 0 | (A(4644), 4652), 0 == (0 | (a = 0 | o[c >> 2]))) s =
									d;
								else
									for (u = a, f = d;;) {
										if (l = (0 | o[(u + 20 | 0) >> 2]) >>> 0 > (0 | o[(u + 28 | 0) >> 2]) >>> 0 ? 0 | Te(u) | f : f, 0 == (0 |
												(i = 0 | o[(u + 56 | 0) >> 2]))) {
											s = l;
											break
										}
										u = i, f = l
									}
								k(4644), n = s
							} else {
								if (!((0 | o[(t + 76 | 0) >> 2]) > -1)) {
									n = 0 | Te(t);
									break
								}
								n = 0 | Te(t)
							}
						} while (0);
						return 0 | n
					},
					___errno_location: q,
					_memset: Me,
					_sbrk: Pe,
					_memcpy: Ce,
					stackAlloc: function(e) {
						var t;
						return t = f, (0 | (f = 15 + (f = f + (e |= 0) | 0) & -16)) >= (0 | l) && g(0 | e), 0 | t
					},
					___uremdi3: Be,
					getTempRet0: function() {
						return 0 | d
					},
					setTempRet0: function(e) {
						d = e |= 0
					},
					_i64Add: Ee,
					dynCall_iiii: function(e, t, r, n) {
						return t |= 0, r |= 0, n |= 0, 0 | Ue[7 & (e |= 0)](0 | t, 0 | r, 0 | n)
					},
					_emscripten_get_global_libc: function() {
						return 4580
					},
					dynCall_ii: function(e, t) {
						return t |= 0, 0 | xe[1 & (e |= 0)](0 | t)
					},
					stackSave: function() {
						return 0 | f
					},
					_free: G,
					runPostSets: function() {},
					_getsign: function(e, t, r) {
						e |= 0, t |= 0, r |= 0;
						var i, a, u, s, c, d, h, p, _, m, y, b = 0,
							v = 0,
							A = 0,
							T = 0,
							w = 0,
							E = 0,
							M = 0,
							S = 0,
							k = 0,
							R = 0;
						y = f, (0 | (f = f + 176 | 0)) >= (0 | l) && g(176), m = y, i = y + 16 | 0, a = y + 136 | 0, s = e, c = t, d =
							r, k = 1591, R = 16 + (S = h = y + 152 | 0) | 0;
						do {
							n[S >> 0] = 0 | n[k >> 0], S = S + 1 | 0, k = k + 1 | 0
						} while ((0 | S) < (0 | R));
						if (0 == (0 | (_ = 0 | X(p = 16 + (((0 | Z(s)) + (0 | Z(c)) | 0) + (0 | Z(d)) | 0) | 0)))) return f = y, 0;
						for (b = 0, Ce(0 | _, 0 | s, 0 | Z(s)), Ce(0 | _ + (b = b + (0 | Z(s)) | 0), 0 | c, 0 | Z(c)), Ce(0 | _ + (b =
								b + (0 | Z(c)) | 0), 0 | d, 0 | Z(d)), b = b + (0 | Z(d)) | 0, v = 0;
							(0 | v) < 16;) w = 255 & (82 ^ 255 & (0 | n[(h + v | 0) >> 0])), n[(h + v | 0) >> 0] = w, v = v + 1 | 0;
						k = h, R = 16 + (S = _ + b | 0) | 0;
						do {
							n[S >> 0] = 0 | n[k >> 0], S = S + 1 | 0, k = k + 1 | 0
						} while ((0 | S) < (0 | R));
						! function(e) {
							var t, r;
							e |= 0, r = f, (0 | (f = f + 16 | 0)) >= (0 | l) && g(16), o[(t = e) >> 2] = 0, o[(t + 4 | 0) >> 2] = 0, o[(
									t + 8 | 0) >> 2] = 1732584193, o[(4 + (t + 8 | 0) | 0) >> 2] = -271733879, o[(8 + (t + 8 | 0) | 0) >> 2] = -
								1732584194, o[(12 + (t + 8 | 0) | 0) >> 2] = 271733878, f = r
						}(i), H(i, _, p), z(i, a, 16), R = 33 + (S = u = 0 | X(33)) | 0;
						do {
							n[S >> 0] = 0, S = S + 1 | 0
						} while ((0 | S) < (0 | R));
						for (A = u, T = 0;
							(0 | T) < 16;) E = A, M = 255 & (0 | n[(a + T | 0) >> 0]), o[m >> 2] = M, oe(E, 1607, m), A = A + 2 | 0, T =
							T + 1 | 0;
						return G(_), f = y, 0 | u
					},
					establishStackSpace: function(e, t) {
						f = e |= 0, l = t |= 0
					},
					stackRestore: function(e) {
						f = e |= 0
					},
					_malloc: X
				}
			}(Module.asmGlobalArg, Module.asmLibraryArg, buffer),
			real__llvm_bswap_i32 = asm._llvm_bswap_i32;
		asm._llvm_bswap_i32 = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__llvm_bswap_i32.apply(
				null, arguments)
		};
		var real__loadtoken = asm._loadtoken;
		asm._loadtoken = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__loadtoken.apply(
				null, arguments)
		};
		var real_getTempRet0 = asm.getTempRet0;
		asm.getTempRet0 = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_getTempRet0.apply(
				null, arguments)
		};
		var real____udivdi3 = asm.___udivdi3;
		asm.___udivdi3 = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real____udivdi3.apply(
				null, arguments)
		};
		var real_setThrew = asm.setThrew;
		asm.setThrew = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_setThrew.apply(null,
				arguments)
		};
		var real__bitshift64Lshr = asm._bitshift64Lshr;
		asm._bitshift64Lshr = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__bitshift64Lshr.apply(
				null, arguments)
		};
		var real__bitshift64Shl = asm._bitshift64Shl;
		asm._bitshift64Shl = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__bitshift64Shl.apply(
				null, arguments)
		};
		var real__fflush = asm._fflush;
		asm._fflush = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__fflush.apply(null,
				arguments)
		};
		var real__sbrk = asm._sbrk;
		asm._sbrk = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__sbrk.apply(null,
				arguments)
		};
		var real____errno_location = asm.___errno_location;
		asm.___errno_location = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real____errno_location.apply(
				null, arguments)
		};
		var real____uremdi3 = asm.___uremdi3;
		asm.___uremdi3 = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real____uremdi3.apply(
				null, arguments)
		};
		var real_stackAlloc = asm.stackAlloc;
		asm.stackAlloc = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_stackAlloc.apply(
				null, arguments)
		};
		var real__i64Subtract = asm._i64Subtract;
		asm._i64Subtract = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__i64Subtract.apply(
				null, arguments)
		};
		var real_setTempRet0 = asm.setTempRet0;
		asm.setTempRet0 = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_setTempRet0.apply(
				null, arguments)
		};
		var real__i64Add = asm._i64Add;
		asm._i64Add = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__i64Add.apply(null,
				arguments)
		};
		var real__emscripten_get_global_libc = asm._emscripten_get_global_libc;
		asm._emscripten_get_global_libc = function() {
			return assert(runtimeInitialized,
					"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
					"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"),
				real__emscripten_get_global_libc.apply(null, arguments)
		};
		var real_stackSave = asm.stackSave;
		asm.stackSave = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_stackSave.apply(null,
				arguments)
		};
		var real__free = asm._free;
		asm._free = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__free.apply(null,
				arguments)
		};
		var real__getsign = asm._getsign;
		asm._getsign = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__getsign.apply(null,
				arguments)
		};
		var real_establishStackSpace = asm.establishStackSpace;
		asm.establishStackSpace = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_establishStackSpace.apply(
				null, arguments)
		};
		var real_stackRestore = asm.stackRestore;
		asm.stackRestore = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real_stackRestore.apply(
				null, arguments)
		};
		var real__malloc = asm._malloc;
		asm._malloc = function() {
			return assert(runtimeInitialized,
				"you need to wait for the runtime to be ready (e.g. wait for main() to be called)"), assert(!runtimeExited,
				"the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)"), real__malloc.apply(null,
				arguments)
		};
		var _llvm_bswap_i32 = Module._llvm_bswap_i32 = asm._llvm_bswap_i32,
			_loadtoken = Module._loadtoken = asm._loadtoken,
			getTempRet0 = Module.getTempRet0 = asm.getTempRet0,
			___udivdi3 = Module.___udivdi3 = asm.___udivdi3,
			setThrew = Module.setThrew = asm.setThrew,
			_bitshift64Lshr = Module._bitshift64Lshr = asm._bitshift64Lshr,
			_bitshift64Shl = Module._bitshift64Shl = asm._bitshift64Shl,
			_fflush = Module._fflush = asm._fflush,
			_memset = Module._memset = asm._memset,
			_sbrk = Module._sbrk = asm._sbrk,
			_memcpy = Module._memcpy = asm._memcpy,
			___errno_location = Module.___errno_location = asm.___errno_location,
			___uremdi3 = Module.___uremdi3 = asm.___uremdi3,
			stackAlloc = Module.stackAlloc = asm.stackAlloc,
			_i64Subtract = Module._i64Subtract = asm._i64Subtract,
			setTempRet0 = Module.setTempRet0 = asm.setTempRet0,
			_i64Add = Module._i64Add = asm._i64Add,
			_emscripten_get_global_libc = Module._emscripten_get_global_libc = asm._emscripten_get_global_libc,
			stackSave = Module.stackSave = asm.stackSave,
			_free = Module._free = asm._free,
			runPostSets = Module.runPostSets = asm.runPostSets,
			_getsign = Module._getsign = asm._getsign,
			establishStackSpace = Module.establishStackSpace = asm.establishStackSpace,
			stackRestore = Module.stackRestore = asm.stackRestore,
			_malloc = Module._malloc = asm._malloc,
			dynCall_ii = Module.dynCall_ii = asm.dynCall_ii,
			dynCall_iiii = Module.dynCall_iiii = asm.dynCall_iiii,
			initialStackTop;

		function ExitStatus(e) {
			this.name = "ExitStatus", this.message = "Program terminated with exit(" + e + ")", this.status = e
		}
		Runtime.stackAlloc = Module.stackAlloc, Runtime.stackSave = Module.stackSave, Runtime.stackRestore = Module.stackRestore,
			Runtime.establishStackSpace = Module.establishStackSpace, Runtime.setTempRet0 = Module.setTempRet0, Runtime.getTempRet0 =
			Module.getTempRet0, Module.asm = asm, ExitStatus.prototype = new Error, ExitStatus.prototype.constructor =
			ExitStatus;
		var preloadStartTime = null;

		function run(e) {
			function t() {
				Module.calledRun || (Module.calledRun = !0, ABORT || (ensureInitRuntime(), preMain(), ENVIRONMENT_IS_WEB && null !==
					preloadStartTime && Module.printErr("pre-main prep time: " + (Date.now() - preloadStartTime) + " ms"), Module
					.onRuntimeInitialized && Module.onRuntimeInitialized(), Module._main && shouldRunNow && Module.callMain(e),
					postRun()))
			}
			e = e || Module.arguments, null === preloadStartTime && (preloadStartTime = Date.now()), runDependencies > 0 || (
				writeStackCookie(), preRun(), runDependencies > 0 || Module.calledRun || (Module.setStatus ? (Module.setStatus(
					"Running..."), setTimeout(function() {
					setTimeout(function() {
						Module.setStatus("")
					}, 1), t()
				}, 1)) : t(), checkStackCookie()))
		}

		function exit(e, t) {
			t && Module.noExitRuntime ? Module.printErr("exit(" + e +
				") implicitly called by end of main(), but noExitRuntime, so not exiting the runtime (you can use emscripten_force_exit, if you want to force a true shutdown)"
			) : (Module.noExitRuntime ? Module.printErr("exit(" + e +
					") called, but noExitRuntime, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)"
				) : (ABORT = !0, STACKTOP = initialStackTop, exitRuntime(), Module.onExit && Module.onExit(e)),
				ENVIRONMENT_IS_NODE && process_on.exit(e), Module.quit(e, new ExitStatus(e)))
		}
		dependenciesFulfilled = function e() {
			Module.calledRun || run(), Module.calledRun || (dependenciesFulfilled = e)
		}, Module.callMain = Module.callMain = function e(t) {
			assert(0 == runDependencies, "cannot call main when async dependencies remain! (listen on __ATMAIN__)"), assert(
					0 == __ATPRERUN__.length, "cannot call main when preRun functions remain to be called"), t = t || [],
				ensureInitRuntime();
			var r = t.length + 1;

			function n() {
				for (var e = 0; e < 3; e++) i.push(0)
			}
			var i = [allocate(intArrayFromString(Module.thisProgram), "i8", ALLOC_NORMAL)];
			n();
			for (var o = 0; o < r - 1; o += 1) i.push(allocate(intArrayFromString(t[o]), "i8", ALLOC_NORMAL)), n();
			i.push(0), i = allocate(i, "i32", ALLOC_NORMAL);
			try {
				exit(Module._main(r, i, 0), !0)
			} catch (e) {
				if (e instanceof ExitStatus) return;
				if ("SimulateInfiniteLoop" == e) return void(Module.noExitRuntime = !0);
				var a = e;
				e && "object" == typeof e && e.stack && (a = [e, e.stack]), Module.printErr("exception thrown: " + a), Module.quit(
					1, e)
			}
		}, Module.run = Module.run = run, Module.exit = Module.exit = exit;
		var abortDecorators = [];

		function abort(e) {
			Module.onAbort && Module.onAbort(e), void 0 !== e ? (Module.print(e), Module.printErr(e), e = JSON.stringify(e)) :
				e = "", ABORT = !0;
			var t = "abort(" + e + ") at " + stackTrace();
			throw abortDecorators && abortDecorators.forEach(function(r) {
				t = r(t, e)
			}), t
		}
		if (Module.abort = Module.abort = abort, Module.preInit)
			for ("function" == typeof Module.preInit && (Module.preInit = [Module.preInit]); Module.preInit.length > 0;)
				Module.preInit.pop()();
		var shouldRunNow = !0;
		Module.noInitialRun && (shouldRunNow = !1), run(), module.exports = Module
	});
	class JsonLoad {
		constructor(e) {
			this.init(), this.set = e, this.data = {}
		}
		init() {}
		getVodJson() {
			const {
				vid: e
			} = this.set, t = `https://player.polyv.net/secure/${e}.js`;
			return new Promise((e, r) => {
				ajxa.request(t).then(t => {
					e(this.cleanData(t))
				})
			})
		}
		async cleanData(e) {
			const t = Object.assign({}, e);
			return t.poster = this.proxy(e.first_image), t.teaserUrl = this.proxy(e.teaser_url), t.adMatter = this.proxy(e.adMatter,
				"matterurl"), this.data = t, await this.handleSrc(), this.data
		}
		async handleSrc() {
			this.setUrl(), this.setEncryptUrl(), await this.setWxaUrl(), this.setPreviewUrl(), this.setAudioUrl(), this.setKeepSourceUrl()
		}
		setUrl() {
			this.data.src = this.data.mp4
		}
		setEncryptUrl() {
			const {
				seed: e,
				hls: t
			} = this.data, {
				ts: r,
				sign: n
			} = this.set;
			1 === e && (this.data.src = t, r && n && t.forEach((e, i) => {
				const o = e.indexOf("?") > -1 ? "&" : "?";
				t[i] = `${e}${o}ts=${r}&sign=${n}`
			}))
		}
		async setWxaUrl() {
			const {
				seed: e,
				hls: t
			} = this.data, {
				wxApp: r,
				pid: n
			} = this.set;
			if (1 !== e || !r || !r.isWx) return;
			const i = await this.getWxToken(),
				o = miniapp.ccall("loadtoken", "string", ["string"], [i]),
				a = JSON.parse(o).data.token;
			t.forEach((e, r) => {
				const i = e.indexOf("?") > -1 ? "&" : "?";
				t[r] = `${e}${i}token=${a}&iswxa=1&pid=${n}`
			})
		}
		async getWxToken() {
			miniapp || console.warn("###请联系客服获取小程序授权加密SDK");
			const {
				wxApp: e,
				vid: t
			} = this.set, {
				wxAppUrl: r
			} = e, n = e.wxUserId || "", i = e.expires || "", o = "1554867859459", a = miniapp.ccall("getsign", "string", [
				"string", "string", "string"
			], [n, t, o.toString()]), u = {
				iswxa: 1,
				isWx: !0,
				vid: t,
				ts: o,
				sign: a,
				wxAppUrl: r,
				wxUserId: n,
				expires: i
			};
			return new Promise(e => {
				ajxa.request(r, "GET", u).then(t => {
					e(t)
				})
			})
		}
		setPreviewUrl() {
			const {
				vid: e,
				isPreviewMode: t
			} = this.set, {
				src: r,
				seed: n
			} = this.data;
			n && t && r.forEach((t, n) => {
				const i = e.substring(0, 32);
				r[n] = t.replace(i, `p_${i}`)
			})
		}
		setAudioUrl() {
			const {
				useAudio: e
			} = this.set, t = this.data.aac_link;
			e && t && (this.data.src = [t])
		}
		setKeepSourceUrl() {
			const {
				keepsource: e
			} = this.data;
			"1" === e && (this.data.src = [this.data.play_source_url])
		}
		proxy(e, t) {
			if (void 0 !== e && 0 !== e.length) return "string" == typeof e ? this.proxyUrl(e) : t ? (e.forEach(e => {
				e[t] = this.proxyUrl(e[t])
			}), e) : void 0
		}
		proxyUrl(e) {
			return e ? `https://router.polyv.net/proxy/${e=e.replace(/^.*?:\/\//g,"")}` : ""
		}
	}
	class ErrorPanel {
		constructor(e) {
			this.set = e, this.initErrorEvent()
		}
		initErrorEvent() {
			this.event = new Map([
				[1001, {
					event: "VID_EMPTY",
					msg: "vid不能为空"
				}],
				[1002, {
					event: "OUT_FLOW",
					msg: "账户没流量"
				}],
				[1003, {
					event: "TIME_OUT_FLOW",
					msg: "点播过期"
				}],
				[1004, {
					event: "LOAD_JSON_FAIL",
					msg: "获取视频信息失败"
				}],
				[1005, {
					event: "LOAD_TOKEN_FAIL",
					msg: "token错误"
				}]
			])
		}
		emit(e) {
			const {
				callback: t
			} = this.set, r = Object.assign({}, {
				type: "error",
				errorCode: e
			}, this.event.get(e));
			"function" == typeof t && t(r), console.error("#polyv_sdk_error:", r)
		}
	}
	var crypt = createCommonjsModule(function(e) {
			var t, r;
			t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = {
				rotl: function(e, t) {
					return e << t | e >>> 32 - t
				},
				rotr: function(e, t) {
					return e << 32 - t | e >>> t
				},
				endian: function(e) {
					if (e.constructor == Number) return 16711935 & r.rotl(e, 8) | 4278255360 & r.rotl(e, 24);
					for (var t = 0; t < e.length; t++) e[t] = r.endian(e[t]);
					return e
				},
				randomBytes: function(e) {
					for (var t = []; e > 0; e--) t.push(Math.floor(256 * Math.random()));
					return t
				},
				bytesToWords: function(e) {
					for (var t = [], r = 0, n = 0; r < e.length; r++, n += 8) t[n >>> 5] |= e[r] << 24 - n % 32;
					return t
				},
				wordsToBytes: function(e) {
					for (var t = [], r = 0; r < 32 * e.length; r += 8) t.push(e[r >>> 5] >>> 24 - r % 32 & 255);
					return t
				},
				bytesToHex: function(e) {
					for (var t = [], r = 0; r < e.length; r++) t.push((e[r] >>> 4).toString(16)), t.push((15 & e[r]).toString(16));
					return t.join("")
				},
				hexToBytes: function(e) {
					for (var t = [], r = 0; r < e.length; r += 2) t.push(parseInt(e.substr(r, 2), 16));
					return t
				},
				bytesToBase64: function(e) {
					for (var r = [], n = 0; n < e.length; n += 3)
						for (var i = e[n] << 16 | e[n + 1] << 8 | e[n + 2], o = 0; o < 4; o++) 8 * n + 6 * o <= 8 * e.length ? r.push(
							t.charAt(i >>> 6 * (3 - o) & 63)) : r.push("=");
					return r.join("")
				},
				base64ToBytes: function(e) {
					e = e.replace(/[^A-Z0-9+\/]/gi, "");
					for (var r = [], n = 0, i = 0; n < e.length; i = ++n % 4) 0 != i && r.push((t.indexOf(e.charAt(n - 1)) & Math.pow(
						2, -2 * i + 8) - 1) << 2 * i | t.indexOf(e.charAt(n)) >>> 6 - 2 * i);
					return r
				}
			}, e.exports = r
		}),
		charenc = {
			utf8: {
				stringToBytes: function(e) {
					return charenc.bin.stringToBytes(unescape(encodeURIComponent(e)))
				},
				bytesToString: function(e) {
					return decodeURIComponent(escape(charenc.bin.bytesToString(e)))
				}
			},
			bin: {
				stringToBytes: function(e) {
					for (var t = [], r = 0; r < e.length; r++) t.push(255 & e.charCodeAt(r));
					return t
				},
				bytesToString: function(e) {
					for (var t = [], r = 0; r < e.length; r++) t.push(String.fromCharCode(e[r]));
					return t.join("")
				}
			}
		},
		charenc_1 = charenc,
		isBuffer_1 = function(e) {
			return null != e && (isBuffer(e) || isSlowBuffer(e) || !!e._isBuffer)
		};

	function isBuffer(e) {
		return !!e.constructor && "function" == typeof e.constructor.isBuffer && e.constructor.isBuffer(e)
	}

	function isSlowBuffer(e) {
		return "function" == typeof e.readFloatLE && "function" == typeof e.slice && isBuffer(e.slice(0, 0))
	}
	var md5 = createCommonjsModule(function(e) {
			var t, r, n, i, o;
			t = crypt, r = charenc_1.utf8, n = isBuffer_1, i = charenc_1.bin, (o = function(e, a) {
				e.constructor == String ? e = a && "binary" === a.encoding ? i.stringToBytes(e) : r.stringToBytes(e) : n(e) ? e =
					Array.prototype.slice.call(e, 0) : Array.isArray(e) || (e = e.toString());
				for (var u = t.bytesToWords(e), s = 8 * e.length, f = 1732584193, l = -271733879, c = -1732584194, d =
						271733878, h = 0; h < u.length; h++) u[h] = 16711935 & (u[h] << 8 | u[h] >>> 24) | 4278255360 & (u[h] << 24 |
					u[h] >>> 8);
				u[s >>> 5] |= 128 << s % 32, u[14 + (s + 64 >>> 9 << 4)] = s;
				var p = o._ff,
					_ = o._gg,
					m = o._hh,
					y = o._ii;
				for (h = 0; h < u.length; h += 16) {
					var g = f,
						b = l,
						v = c,
						A = d;
					f = p(f, l, c, d, u[h + 0], 7, -680876936), d = p(d, f, l, c, u[h + 1], 12, -389564586), c = p(c, d, f, l, u[h +
							2], 17, 606105819), l = p(l, c, d, f, u[h + 3], 22, -1044525330), f = p(f, l, c, d, u[h + 4], 7, -176418897),
						d = p(d, f, l, c, u[h + 5], 12, 1200080426), c = p(c, d, f, l, u[h + 6], 17, -1473231341), l = p(l, c, d, f,
							u[h + 7], 22, -45705983), f = p(f, l, c, d, u[h + 8], 7, 1770035416), d = p(d, f, l, c, u[h + 9], 12, -
							1958414417), c = p(c, d, f, l, u[h + 10], 17, -42063), l = p(l, c, d, f, u[h + 11], 22, -1990404162), f = p(
							f, l, c, d, u[h + 12], 7, 1804603682), d = p(d, f, l, c, u[h + 13], 12, -40341101), c = p(c, d, f, l, u[h +
							14], 17, -1502002290), f = _(f, l = p(l, c, d, f, u[h + 15], 22, 1236535329), c, d, u[h + 1], 5, -165796510),
						d = _(d, f, l, c, u[h + 6], 9, -1069501632), c = _(c, d, f, l, u[h + 11], 14, 643717713), l = _(l, c, d, f, u[
							h + 0], 20, -373897302), f = _(f, l, c, d, u[h + 5], 5, -701558691), d = _(d, f, l, c, u[h + 10], 9,
							38016083), c = _(c, d, f, l, u[h + 15], 14, -660478335), l = _(l, c, d, f, u[h + 4], 20, -405537848), f = _(
							f, l, c, d, u[h + 9], 5, 568446438), d = _(d, f, l, c, u[h + 14], 9, -1019803690), c = _(c, d, f, l, u[h + 3],
							14, -187363961), l = _(l, c, d, f, u[h + 8], 20, 1163531501), f = _(f, l, c, d, u[h + 13], 5, -1444681467),
						d = _(d, f, l, c, u[h + 2], 9, -51403784), c = _(c, d, f, l, u[h + 7], 14, 1735328473), f = m(f, l = _(l, c,
							d, f, u[h + 12], 20, -1926607734), c, d, u[h + 5], 4, -378558), d = m(d, f, l, c, u[h + 8], 11, -2022574463),
						c = m(c, d, f, l, u[h + 11], 16, 1839030562), l = m(l, c, d, f, u[h + 14], 23, -35309556), f = m(f, l, c, d,
							u[h + 1], 4, -1530992060), d = m(d, f, l, c, u[h + 4], 11, 1272893353), c = m(c, d, f, l, u[h + 7], 16, -
							155497632), l = m(l, c, d, f, u[h + 10], 23, -1094730640), f = m(f, l, c, d, u[h + 13], 4, 681279174), d = m(
							d, f, l, c, u[h + 0], 11, -358537222), c = m(c, d, f, l, u[h + 3], 16, -722521979), l = m(l, c, d, f, u[h +
							6], 23, 76029189), f = m(f, l, c, d, u[h + 9], 4, -640364487), d = m(d, f, l, c, u[h + 12], 11, -421815835),
						c = m(c, d, f, l, u[h + 15], 16, 530742520), f = y(f, l = m(l, c, d, f, u[h + 2], 23, -995338651), c, d, u[h +
							0], 6, -198630844), d = y(d, f, l, c, u[h + 7], 10, 1126891415), c = y(c, d, f, l, u[h + 14], 15, -
							1416354905), l = y(l, c, d, f, u[h + 5], 21, -57434055), f = y(f, l, c, d, u[h + 12], 6, 1700485571), d = y(
							d, f, l, c, u[h + 3], 10, -1894986606), c = y(c, d, f, l, u[h + 10], 15, -1051523), l = y(l, c, d, f, u[h +
							1], 21, -2054922799), f = y(f, l, c, d, u[h + 8], 6, 1873313359), d = y(d, f, l, c, u[h + 15], 10, -30611744),
						c = y(c, d, f, l, u[h + 6], 15, -1560198380), l = y(l, c, d, f, u[h + 13], 21, 1309151649), f = y(f, l, c, d,
							u[h + 4], 6, -145523070), d = y(d, f, l, c, u[h + 11], 10, -1120210379), c = y(c, d, f, l, u[h + 2], 15,
							718787259), l = y(l, c, d, f, u[h + 9], 21, -343485551), f = f + g >>> 0, l = l + b >>> 0, c = c + v >>> 0,
						d = d + A >>> 0
				}
				return t.endian([f, l, c, d])
			})._ff = function(e, t, r, n, i, o, a) {
				var u = e + (t & r | ~t & n) + (i >>> 0) + a;
				return (u << o | u >>> 32 - o) + t
			}, o._gg = function(e, t, r, n, i, o, a) {
				var u = e + (t & n | r & ~n) + (i >>> 0) + a;
				return (u << o | u >>> 32 - o) + t
			}, o._hh = function(e, t, r, n, i, o, a) {
				var u = e + (t ^ r ^ n) + (i >>> 0) + a;
				return (u << o | u >>> 32 - o) + t
			}, o._ii = function(e, t, r, n, i, o, a) {
				var u = e + (r ^ (t | ~n)) + (i >>> 0) + a;
				return (u << o | u >>> 32 - o) + t
			}, o._blocksize = 16, o._digestsize = 16, e.exports = function(e, r) {
				if (null == e) throw new Error("Illegal argument " + e);
				var n = t.wordsToBytes(o(e, r));
				return r && r.asBytes ? n : r && r.asString ? i.bytesToString(n) : t.bytesToHex(n)
			}
		}),
		lookup = [],
		revLookup = [],
		Arr = "undefined" != typeof Uint8Array ? Uint8Array : Array,
		inited = !1;

	function init() {
		inited = !0;
		for (var e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", t = 0, r = e.length; t < r; ++t)
			lookup[t] = e[t], revLookup[e.charCodeAt(t)] = t;
		revLookup["-".charCodeAt(0)] = 62, revLookup["_".charCodeAt(0)] = 63
	}

	function toByteArray(e) {
		var t, r, n, i, o, a;
		inited || init();
		var u = e.length;
		if (u % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
		o = "=" === e[u - 2] ? 2 : "=" === e[u - 1] ? 1 : 0, a = new Arr(3 * u / 4 - o), n = o > 0 ? u - 4 : u;
		var s = 0;
		for (t = 0, r = 0; t < n; t += 4, r += 3) i = revLookup[e.charCodeAt(t)] << 18 | revLookup[e.charCodeAt(t + 1)] <<
			12 | revLookup[e.charCodeAt(t + 2)] << 6 | revLookup[e.charCodeAt(t + 3)], a[s++] = i >> 16 & 255, a[s++] = i >> 8 &
			255, a[s++] = 255 & i;
		return 2 === o ? (i = revLookup[e.charCodeAt(t)] << 2 | revLookup[e.charCodeAt(t + 1)] >> 4, a[s++] = 255 & i) : 1 ===
			o && (i = revLookup[e.charCodeAt(t)] << 10 | revLookup[e.charCodeAt(t + 1)] << 4 | revLookup[e.charCodeAt(t + 2)] >>
				2, a[s++] = i >> 8 & 255, a[s++] = 255 & i), a
	}

	function tripletToBase64(e) {
		return lookup[e >> 18 & 63] + lookup[e >> 12 & 63] + lookup[e >> 6 & 63] + lookup[63 & e]
	}

	function encodeChunk(e, t, r) {
		for (var n, i = [], o = t; o < r; o += 3) n = (e[o] << 16) + (e[o + 1] << 8) + e[o + 2], i.push(tripletToBase64(n));
		return i.join("")
	}

	function fromByteArray(e) {
		var t;
		inited || init();
		for (var r = e.length, n = r % 3, i = "", o = [], a = 16383, u = 0, s = r - n; u < s; u += a) o.push(encodeChunk(e,
			u, u + a > s ? s : u + a));
		return 1 === n ? (t = e[r - 1], i += lookup[t >> 2], i += lookup[t << 4 & 63], i += "==") : 2 === n && (t = (e[r - 2] <<
			8) + e[r - 1], i += lookup[t >> 10], i += lookup[t >> 4 & 63], i += lookup[t << 2 & 63], i += "="), o.push(i), o.join(
			"")
	}

	function read$1(e, t, r, n, i) {
		var o, a, u = 8 * i - n - 1,
			s = (1 << u) - 1,
			f = s >> 1,
			l = -7,
			c = r ? i - 1 : 0,
			d = r ? -1 : 1,
			h = e[t + c];
		for (c += d, o = h & (1 << -l) - 1, h >>= -l, l += u; l > 0; o = 256 * o + e[t + c], c += d, l -= 8);
		for (a = o & (1 << -l) - 1, o >>= -l, l += n; l > 0; a = 256 * a + e[t + c], c += d, l -= 8);
		if (0 === o) o = 1 - f;
		else {
			if (o === s) return a ? NaN : 1 / 0 * (h ? -1 : 1);
			a += Math.pow(2, n), o -= f
		}
		return (h ? -1 : 1) * a * Math.pow(2, o - n)
	}

	function write(e, t, r, n, i, o) {
		var a, u, s, f = 8 * o - i - 1,
			l = (1 << f) - 1,
			c = l >> 1,
			d = 23 === i ? Math.pow(2, -24) - Math.pow(2, -77) : 0,
			h = n ? 0 : o - 1,
			p = n ? 1 : -1,
			_ = t < 0 || 0 === t && 1 / t < 0 ? 1 : 0;
		for (t = Math.abs(t), isNaN(t) || t === 1 / 0 ? (u = isNaN(t) ? 1 : 0, a = l) : (a = Math.floor(Math.log(t) / Math.LN2),
				t * (s = Math.pow(2, -a)) < 1 && (a--, s *= 2), (t += a + c >= 1 ? d / s : d * Math.pow(2, 1 - c)) * s >= 2 && (a++,
					s /= 2), a + c >= l ? (u = 0, a = l) : a + c >= 1 ? (u = (t * s - 1) * Math.pow(2, i), a += c) : (u = t * Math.pow(
					2, c - 1) * Math.pow(2, i), a = 0)); i >= 8; e[r + h] = 255 & u, h += p, u /= 256, i -= 8);
		for (a = a << i | u, f += i; f > 0; e[r + h] = 255 & a, h += p, a /= 256, f -= 8);
		e[r + h - p] |= 128 * _
	}
	var toString = {}.toString,
		isArray = Array.isArray || function(e) {
			return "[object Array]" == toString.call(e)
		},
		INSPECT_MAX_BYTES = 50;
	Buffer.TYPED_ARRAY_SUPPORT = void 0 === global.TYPED_ARRAY_SUPPORT || global.TYPED_ARRAY_SUPPORT;
	var _kMaxLength = kMaxLength();

	function kMaxLength() {
		return Buffer.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823
	}

	function createBuffer(e, t) {
		if (kMaxLength() < t) throw new RangeError("Invalid typed array length");
		return Buffer.TYPED_ARRAY_SUPPORT ? (e = new Uint8Array(t)).__proto__ = Buffer.prototype : (null === e && (e = new Buffer(
			t)), e.length = t), e
	}

	function Buffer(e, t, r) {
		if (!(Buffer.TYPED_ARRAY_SUPPORT || this instanceof Buffer)) return new Buffer(e, t, r);
		if ("number" == typeof e) {
			if ("string" == typeof t) throw new Error("If encoding is specified then the first argument must be a string");
			return allocUnsafe(this, e)
		}
		return from(this, e, t, r)
	}

	function from(e, t, r, n) {
		if ("number" == typeof t) throw new TypeError('"value" argument must not be a number');
		return "undefined" != typeof ArrayBuffer && t instanceof ArrayBuffer ? fromArrayBuffer(e, t, r, n) : "string" ==
			typeof t ? fromString(e, t, r) : fromObject(e, t)
	}

	function assertSize(e) {
		if ("number" != typeof e) throw new TypeError('"size" argument must be a number');
		if (e < 0) throw new RangeError('"size" argument must not be negative')
	}

	function alloc(e, t, r, n) {
		return assertSize(t), t <= 0 ? createBuffer(e, t) : void 0 !== r ? "string" == typeof n ? createBuffer(e, t).fill(r,
			n) : createBuffer(e, t).fill(r) : createBuffer(e, t)
	}

	function allocUnsafe(e, t) {
		if (assertSize(t), e = createBuffer(e, t < 0 ? 0 : 0 | checked(t)), !Buffer.TYPED_ARRAY_SUPPORT)
			for (var r = 0; r < t; ++r) e[r] = 0;
		return e
	}

	function fromString(e, t, r) {
		if ("string" == typeof r && "" !== r || (r = "utf8"), !Buffer.isEncoding(r)) throw new TypeError(
			'"encoding" must be a valid string encoding');
		var n = 0 | byteLength(t, r),
			i = (e = createBuffer(e, n)).write(t, r);
		return i !== n && (e = e.slice(0, i)), e
	}

	function fromArrayLike(e, t) {
		var r = t.length < 0 ? 0 : 0 | checked(t.length);
		e = createBuffer(e, r);
		for (var n = 0; n < r; n += 1) e[n] = 255 & t[n];
		return e
	}

	function fromArrayBuffer(e, t, r, n) {
		if (t.byteLength, r < 0 || t.byteLength < r) throw new RangeError("'offset' is out of bounds");
		if (t.byteLength < r + (n || 0)) throw new RangeError("'length' is out of bounds");
		return t = void 0 === r && void 0 === n ? new Uint8Array(t) : void 0 === n ? new Uint8Array(t, r) : new Uint8Array(t,
			r, n), Buffer.TYPED_ARRAY_SUPPORT ? (e = t).__proto__ = Buffer.prototype : e = fromArrayLike(e, t), e
	}

	function fromObject(e, t) {
		if (internalIsBuffer(t)) {
			var r = 0 | checked(t.length);
			return 0 === (e = createBuffer(e, r)).length ? e : (t.copy(e, 0, 0, r), e)
		}
		if (t) {
			if ("undefined" != typeof ArrayBuffer && t.buffer instanceof ArrayBuffer || "length" in t) return "number" !=
				typeof t.length || isnan(t.length) ? createBuffer(e, 0) : fromArrayLike(e, t);
			if ("Buffer" === t.type && isArray(t.data)) return fromArrayLike(e, t.data)
		}
		throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")
	}

	function checked(e) {
		if (e >= kMaxLength()) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength()
			.toString(16) + " bytes");
		return 0 | e
	}

	function SlowBuffer(e) {
		return +e != e && (e = 0), Buffer.alloc(+e)
	}

	function internalIsBuffer(e) {
		return !(null == e || !e._isBuffer)
	}

	function byteLength(e, t) {
		if (internalIsBuffer(e)) return e.length;
		if ("undefined" != typeof ArrayBuffer && "function" == typeof ArrayBuffer.isView && (ArrayBuffer.isView(e) || e instanceof ArrayBuffer))
			return e.byteLength;
		"string" != typeof e && (e = "" + e);
		var r = e.length;
		if (0 === r) return 0;
		for (var n = !1;;) switch (t) {
			case "ascii":
			case "latin1":
			case "binary":
				return r;
			case "utf8":
			case "utf-8":
			case void 0:
				return utf8ToBytes(e).length;
			case "ucs2":
			case "ucs-2":
			case "utf16le":
			case "utf-16le":
				return 2 * r;
			case "hex":
				return r >>> 1;
			case "base64":
				return base64ToBytes(e).length;
			default:
				if (n) return utf8ToBytes(e).length;
				t = ("" + t).toLowerCase(), n = !0
		}
	}

	function slowToString(e, t, r) {
		var n = !1;
		if ((void 0 === t || t < 0) && (t = 0), t > this.length) return "";
		if ((void 0 === r || r > this.length) && (r = this.length), r <= 0) return "";
		if ((r >>>= 0) <= (t >>>= 0)) return "";
		for (e || (e = "utf8");;) switch (e) {
			case "hex":
				return hexSlice(this, t, r);
			case "utf8":
			case "utf-8":
				return utf8Slice(this, t, r);
			case "ascii":
				return asciiSlice(this, t, r);
			case "latin1":
			case "binary":
				return latin1Slice(this, t, r);
			case "base64":
				return base64Slice(this, t, r);
			case "ucs2":
			case "ucs-2":
			case "utf16le":
			case "utf-16le":
				return utf16leSlice(this, t, r);
			default:
				if (n) throw new TypeError("Unknown encoding: " + e);
				e = (e + "").toLowerCase(), n = !0
		}
	}

	function swap(e, t, r) {
		var n = e[t];
		e[t] = e[r], e[r] = n
	}

	function bidirectionalIndexOf(e, t, r, n, i) {
		if (0 === e.length) return -1;
		if ("string" == typeof r ? (n = r, r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648),
			r = +r, isNaN(r) && (r = i ? 0 : e.length - 1), r < 0 && (r = e.length + r), r >= e.length) {
			if (i) return -1;
			r = e.length - 1
		} else if (r < 0) {
			if (!i) return -1;
			r = 0
		}
		if ("string" == typeof t && (t = Buffer.from(t, n)), internalIsBuffer(t)) return 0 === t.length ? -1 : arrayIndexOf(
			e, t, r, n, i);
		if ("number" == typeof t) return t &= 255, Buffer.TYPED_ARRAY_SUPPORT && "function" == typeof Uint8Array.prototype.indexOf ?
			i ? Uint8Array.prototype.indexOf.call(e, t, r) : Uint8Array.prototype.lastIndexOf.call(e, t, r) : arrayIndexOf(e,
				[t], r, n, i);
		throw new TypeError("val must be string, number or Buffer")
	}

	function arrayIndexOf(e, t, r, n, i) {
		var o, a = 1,
			u = e.length,
			s = t.length;
		if (void 0 !== n && ("ucs2" === (n = String(n).toLowerCase()) || "ucs-2" === n || "utf16le" === n || "utf-16le" ===
				n)) {
			if (e.length < 2 || t.length < 2) return -1;
			a = 2, u /= 2, s /= 2, r /= 2
		}

		function f(e, t) {
			return 1 === a ? e[t] : e.readUInt16BE(t * a)
		}
		if (i) {
			var l = -1;
			for (o = r; o < u; o++)
				if (f(e, o) === f(t, -1 === l ? 0 : o - l)) {
					if (-1 === l && (l = o), o - l + 1 === s) return l * a
				} else -1 !== l && (o -= o - l), l = -1
		} else
			for (r + s > u && (r = u - s), o = r; o >= 0; o--) {
				for (var c = !0, d = 0; d < s; d++)
					if (f(e, o + d) !== f(t, d)) {
						c = !1;
						break
					} if (c) return o
			}
		return -1
	}

	function hexWrite(e, t, r, n) {
		r = Number(r) || 0;
		var i = e.length - r;
		n ? (n = Number(n)) > i && (n = i) : n = i;
		var o = t.length;
		if (o % 2 != 0) throw new TypeError("Invalid hex string");
		n > o / 2 && (n = o / 2);
		for (var a = 0; a < n; ++a) {
			var u = parseInt(t.substr(2 * a, 2), 16);
			if (isNaN(u)) return a;
			e[r + a] = u
		}
		return a
	}

	function utf8Write(e, t, r, n) {
		return blitBuffer(utf8ToBytes(t, e.length - r), e, r, n)
	}

	function asciiWrite(e, t, r, n) {
		return blitBuffer(asciiToBytes(t), e, r, n)
	}

	function latin1Write(e, t, r, n) {
		return asciiWrite(e, t, r, n)
	}

	function base64Write(e, t, r, n) {
		return blitBuffer(base64ToBytes(t), e, r, n)
	}

	function ucs2Write(e, t, r, n) {
		return blitBuffer(utf16leToBytes(t, e.length - r), e, r, n)
	}

	function base64Slice(e, t, r) {
		return 0 === t && r === e.length ? fromByteArray(e) : fromByteArray(e.slice(t, r))
	}

	function utf8Slice(e, t, r) {
		r = Math.min(e.length, r);
		for (var n = [], i = t; i < r;) {
			var o, a, u, s, f = e[i],
				l = null,
				c = f > 239 ? 4 : f > 223 ? 3 : f > 191 ? 2 : 1;
			if (i + c <= r) switch (c) {
				case 1:
					f < 128 && (l = f);
					break;
				case 2:
					128 == (192 & (o = e[i + 1])) && (s = (31 & f) << 6 | 63 & o) > 127 && (l = s);
					break;
				case 3:
					o = e[i + 1], a = e[i + 2], 128 == (192 & o) && 128 == (192 & a) && (s = (15 & f) << 12 | (63 & o) << 6 | 63 & a) >
						2047 && (s < 55296 || s > 57343) && (l = s);
					break;
				case 4:
					o = e[i + 1], a = e[i + 2], u = e[i + 3], 128 == (192 & o) && 128 == (192 & a) && 128 == (192 & u) && (s = (15 &
						f) << 18 | (63 & o) << 12 | (63 & a) << 6 | 63 & u) > 65535 && s < 1114112 && (l = s)
			}
			null === l ? (l = 65533, c = 1) : l > 65535 && (l -= 65536, n.push(l >>> 10 & 1023 | 55296), l = 56320 | 1023 & l),
				n.push(l), i += c
		}
		return decodeCodePointsArray(n)
	}
	Buffer.poolSize = 8192, Buffer._augment = function(e) {
			return e.__proto__ = Buffer.prototype, e
		}, Buffer.from = function(e, t, r) {
			return from(null, e, t, r)
		}, Buffer.TYPED_ARRAY_SUPPORT && (Buffer.prototype.__proto__ = Uint8Array.prototype, Buffer.__proto__ = Uint8Array),
		Buffer.alloc = function(e, t, r) {
			return alloc(null, e, t, r)
		}, Buffer.allocUnsafe = function(e) {
			return allocUnsafe(null, e)
		}, Buffer.allocUnsafeSlow = function(e) {
			return allocUnsafe(null, e)
		}, Buffer.isBuffer = isBuffer$1, Buffer.compare = function(e, t) {
			if (!internalIsBuffer(e) || !internalIsBuffer(t)) throw new TypeError("Arguments must be Buffers");
			if (e === t) return 0;
			for (var r = e.length, n = t.length, i = 0, o = Math.min(r, n); i < o; ++i)
				if (e[i] !== t[i]) {
					r = e[i], n = t[i];
					break
				} return r < n ? -1 : n < r ? 1 : 0
		}, Buffer.isEncoding = function(e) {
			switch (String(e).toLowerCase()) {
				case "hex":
				case "utf8":
				case "utf-8":
				case "ascii":
				case "latin1":
				case "binary":
				case "base64":
				case "ucs2":
				case "ucs-2":
				case "utf16le":
				case "utf-16le":
					return !0;
				default:
					return !1
			}
		}, Buffer.concat = function(e, t) {
			if (!isArray(e)) throw new TypeError('"list" argument must be an Array of Buffers');
			if (0 === e.length) return Buffer.alloc(0);
			var r;
			if (void 0 === t)
				for (t = 0, r = 0; r < e.length; ++r) t += e[r].length;
			var n = Buffer.allocUnsafe(t),
				i = 0;
			for (r = 0; r < e.length; ++r) {
				var o = e[r];
				if (!internalIsBuffer(o)) throw new TypeError('"list" argument must be an Array of Buffers');
				o.copy(n, i), i += o.length
			}
			return n
		}, Buffer.byteLength = byteLength, Buffer.prototype._isBuffer = !0, Buffer.prototype.swap16 = function() {
			var e = this.length;
			if (e % 2 != 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
			for (var t = 0; t < e; t += 2) swap(this, t, t + 1);
			return this
		}, Buffer.prototype.swap32 = function() {
			var e = this.length;
			if (e % 4 != 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
			for (var t = 0; t < e; t += 4) swap(this, t, t + 3), swap(this, t + 1, t + 2);
			return this
		}, Buffer.prototype.swap64 = function() {
			var e = this.length;
			if (e % 8 != 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
			for (var t = 0; t < e; t += 8) swap(this, t, t + 7), swap(this, t + 1, t + 6), swap(this, t + 2, t + 5), swap(this,
				t + 3, t + 4);
			return this
		}, Buffer.prototype.toString = function() {
			var e = 0 | this.length;
			return 0 === e ? "" : 0 === arguments.length ? utf8Slice(this, 0, e) : slowToString.apply(this, arguments)
		}, Buffer.prototype.equals = function(e) {
			if (!internalIsBuffer(e)) throw new TypeError("Argument must be a Buffer");
			return this === e || 0 === Buffer.compare(this, e)
		}, Buffer.prototype.inspect = function() {
			var e = "",
				t = INSPECT_MAX_BYTES;
			return this.length > 0 && (e = this.toString("hex", 0, t).match(/.{2}/g).join(" "), this.length > t && (e +=
				" ... ")), "<Buffer " + e + ">"
		}, Buffer.prototype.compare = function(e, t, r, n, i) {
			if (!internalIsBuffer(e)) throw new TypeError("Argument must be a Buffer");
			if (void 0 === t && (t = 0), void 0 === r && (r = e ? e.length : 0), void 0 === n && (n = 0), void 0 === i && (i =
					this.length), t < 0 || r > e.length || n < 0 || i > this.length) throw new RangeError("out of range index");
			if (n >= i && t >= r) return 0;
			if (n >= i) return -1;
			if (t >= r) return 1;
			if (this === e) return 0;
			for (var o = (i >>>= 0) - (n >>>= 0), a = (r >>>= 0) - (t >>>= 0), u = Math.min(o, a), s = this.slice(n, i), f = e.slice(
					t, r), l = 0; l < u; ++l)
				if (s[l] !== f[l]) {
					o = s[l], a = f[l];
					break
				} return o < a ? -1 : a < o ? 1 : 0
		}, Buffer.prototype.includes = function(e, t, r) {
			return -1 !== this.indexOf(e, t, r)
		}, Buffer.prototype.indexOf = function(e, t, r) {
			return bidirectionalIndexOf(this, e, t, r, !0)
		}, Buffer.prototype.lastIndexOf = function(e, t, r) {
			return bidirectionalIndexOf(this, e, t, r, !1)
		}, Buffer.prototype.write = function(e, t, r, n) {
			if (void 0 === t) n = "utf8", r = this.length, t = 0;
			else if (void 0 === r && "string" == typeof t) n = t, r = this.length, t = 0;
			else {
				if (!isFinite(t)) throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
				t |= 0, isFinite(r) ? (r |= 0, void 0 === n && (n = "utf8")) : (n = r, r = void 0)
			}
			var i = this.length - t;
			if ((void 0 === r || r > i) && (r = i), e.length > 0 && (r < 0 || t < 0) || t > this.length) throw new RangeError(
				"Attempt to write outside buffer bounds");
			n || (n = "utf8");
			for (var o = !1;;) switch (n) {
				case "hex":
					return hexWrite(this, e, t, r);
				case "utf8":
				case "utf-8":
					return utf8Write(this, e, t, r);
				case "ascii":
					return asciiWrite(this, e, t, r);
				case "latin1":
				case "binary":
					return latin1Write(this, e, t, r);
				case "base64":
					return base64Write(this, e, t, r);
				case "ucs2":
				case "ucs-2":
				case "utf16le":
				case "utf-16le":
					return ucs2Write(this, e, t, r);
				default:
					if (o) throw new TypeError("Unknown encoding: " + n);
					n = ("" + n).toLowerCase(), o = !0
			}
		}, Buffer.prototype.toJSON = function() {
			return {
				type: "Buffer",
				data: Array.prototype.slice.call(this._arr || this, 0)
			}
		};
	var MAX_ARGUMENTS_LENGTH = 4096;

	function decodeCodePointsArray(e) {
		var t = e.length;
		if (t <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, e);
		for (var r = "", n = 0; n < t;) r += String.fromCharCode.apply(String, e.slice(n, n += MAX_ARGUMENTS_LENGTH));
		return r
	}

	function asciiSlice(e, t, r) {
		var n = "";
		r = Math.min(e.length, r);
		for (var i = t; i < r; ++i) n += String.fromCharCode(127 & e[i]);
		return n
	}

	function latin1Slice(e, t, r) {
		var n = "";
		r = Math.min(e.length, r);
		for (var i = t; i < r; ++i) n += String.fromCharCode(e[i]);
		return n
	}

	function hexSlice(e, t, r) {
		var n = e.length;
		(!t || t < 0) && (t = 0), (!r || r < 0 || r > n) && (r = n);
		for (var i = "", o = t; o < r; ++o) i += toHex(e[o]);
		return i
	}

	function utf16leSlice(e, t, r) {
		for (var n = e.slice(t, r), i = "", o = 0; o < n.length; o += 2) i += String.fromCharCode(n[o] + 256 * n[o + 1]);
		return i
	}

	function checkOffset(e, t, r) {
		if (e % 1 != 0 || e < 0) throw new RangeError("offset is not uint");
		if (e + t > r) throw new RangeError("Trying to access beyond buffer length")
	}

	function checkInt(e, t, r, n, i, o) {
		if (!internalIsBuffer(e)) throw new TypeError('"buffer" argument must be a Buffer instance');
		if (t > i || t < o) throw new RangeError('"value" argument is out of bounds');
		if (r + n > e.length) throw new RangeError("Index out of range")
	}

	function objectWriteUInt16(e, t, r, n) {
		t < 0 && (t = 65535 + t + 1);
		for (var i = 0, o = Math.min(e.length - r, 2); i < o; ++i) e[r + i] = (t & 255 << 8 * (n ? i : 1 - i)) >>> 8 * (n ?
			i : 1 - i)
	}

	function objectWriteUInt32(e, t, r, n) {
		t < 0 && (t = 4294967295 + t + 1);
		for (var i = 0, o = Math.min(e.length - r, 4); i < o; ++i) e[r + i] = t >>> 8 * (n ? i : 3 - i) & 255
	}

	function checkIEEE754(e, t, r, n, i, o) {
		if (r + n > e.length) throw new RangeError("Index out of range");
		if (r < 0) throw new RangeError("Index out of range")
	}

	function writeFloat(e, t, r, n, i) {
		return i || checkIEEE754(e, t, r, 4), write(e, t, r, n, 23, 4), r + 4
	}

	function writeDouble(e, t, r, n, i) {
		return i || checkIEEE754(e, t, r, 8), write(e, t, r, n, 52, 8), r + 8
	}
	Buffer.prototype.slice = function(e, t) {
		var r, n = this.length;
		if ((e = ~~e) < 0 ? (e += n) < 0 && (e = 0) : e > n && (e = n), (t = void 0 === t ? n : ~~t) < 0 ? (t += n) < 0 &&
			(t = 0) : t > n && (t = n), t < e && (t = e), Buffer.TYPED_ARRAY_SUPPORT)(r = this.subarray(e, t)).__proto__ =
			Buffer.prototype;
		else {
			var i = t - e;
			r = new Buffer(i, void 0);
			for (var o = 0; o < i; ++o) r[o] = this[o + e]
		}
		return r
	}, Buffer.prototype.readUIntLE = function(e, t, r) {
		e |= 0, t |= 0, r || checkOffset(e, t, this.length);
		for (var n = this[e], i = 1, o = 0; ++o < t && (i *= 256);) n += this[e + o] * i;
		return n
	}, Buffer.prototype.readUIntBE = function(e, t, r) {
		e |= 0, t |= 0, r || checkOffset(e, t, this.length);
		for (var n = this[e + --t], i = 1; t > 0 && (i *= 256);) n += this[e + --t] * i;
		return n
	}, Buffer.prototype.readUInt8 = function(e, t) {
		return t || checkOffset(e, 1, this.length), this[e]
	}, Buffer.prototype.readUInt16LE = function(e, t) {
		return t || checkOffset(e, 2, this.length), this[e] | this[e + 1] << 8
	}, Buffer.prototype.readUInt16BE = function(e, t) {
		return t || checkOffset(e, 2, this.length), this[e] << 8 | this[e + 1]
	}, Buffer.prototype.readUInt32LE = function(e, t) {
		return t || checkOffset(e, 4, this.length), (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + 16777216 * this[e +
			3]
	}, Buffer.prototype.readUInt32BE = function(e, t) {
		return t || checkOffset(e, 4, this.length), 16777216 * this[e] + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3])
	}, Buffer.prototype.readIntLE = function(e, t, r) {
		e |= 0, t |= 0, r || checkOffset(e, t, this.length);
		for (var n = this[e], i = 1, o = 0; ++o < t && (i *= 256);) n += this[e + o] * i;
		return n >= (i *= 128) && (n -= Math.pow(2, 8 * t)), n
	}, Buffer.prototype.readIntBE = function(e, t, r) {
		e |= 0, t |= 0, r || checkOffset(e, t, this.length);
		for (var n = t, i = 1, o = this[e + --n]; n > 0 && (i *= 256);) o += this[e + --n] * i;
		return o >= (i *= 128) && (o -= Math.pow(2, 8 * t)), o
	}, Buffer.prototype.readInt8 = function(e, t) {
		return t || checkOffset(e, 1, this.length), 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e]
	}, Buffer.prototype.readInt16LE = function(e, t) {
		t || checkOffset(e, 2, this.length);
		var r = this[e] | this[e + 1] << 8;
		return 32768 & r ? 4294901760 | r : r
	}, Buffer.prototype.readInt16BE = function(e, t) {
		t || checkOffset(e, 2, this.length);
		var r = this[e + 1] | this[e] << 8;
		return 32768 & r ? 4294901760 | r : r
	}, Buffer.prototype.readInt32LE = function(e, t) {
		return t || checkOffset(e, 4, this.length), this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24
	}, Buffer.prototype.readInt32BE = function(e, t) {
		return t || checkOffset(e, 4, this.length), this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]
	}, Buffer.prototype.readFloatLE = function(e, t) {
		return t || checkOffset(e, 4, this.length), read$1(this, e, !0, 23, 4)
	}, Buffer.prototype.readFloatBE = function(e, t) {
		return t || checkOffset(e, 4, this.length), read$1(this, e, !1, 23, 4)
	}, Buffer.prototype.readDoubleLE = function(e, t) {
		return t || checkOffset(e, 8, this.length), read$1(this, e, !0, 52, 8)
	}, Buffer.prototype.readDoubleBE = function(e, t) {
		return t || checkOffset(e, 8, this.length), read$1(this, e, !1, 52, 8)
	}, Buffer.prototype.writeUIntLE = function(e, t, r, n) {
		(e = +e, t |= 0, r |= 0, n) || checkInt(this, e, t, r, Math.pow(2, 8 * r) - 1, 0);
		var i = 1,
			o = 0;
		for (this[t] = 255 & e; ++o < r && (i *= 256);) this[t + o] = e / i & 255;
		return t + r
	}, Buffer.prototype.writeUIntBE = function(e, t, r, n) {
		(e = +e, t |= 0, r |= 0, n) || checkInt(this, e, t, r, Math.pow(2, 8 * r) - 1, 0);
		var i = r - 1,
			o = 1;
		for (this[t + i] = 255 & e; --i >= 0 && (o *= 256);) this[t + i] = e / o & 255;
		return t + r
	}, Buffer.prototype.writeUInt8 = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 1, 255, 0), Buffer.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)),
			this[t] = 255 & e, t + 1
	}, Buffer.prototype.writeUInt16LE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 2, 65535, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = 255 & e,
			this[t + 1] = e >>> 8) : objectWriteUInt16(this, e, t, !0), t + 2
	}, Buffer.prototype.writeUInt16BE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 2, 65535, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 8,
			this[t + 1] = 255 & e) : objectWriteUInt16(this, e, t, !1), t + 2
	}, Buffer.prototype.writeUInt32LE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 4, 4294967295, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[t + 3] = e >>>
			24, this[t + 2] = e >>> 16, this[t + 1] = e >>> 8, this[t] = 255 & e) : objectWriteUInt32(this, e, t, !0), t + 4
	}, Buffer.prototype.writeUInt32BE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 4, 4294967295, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = e >>>
				24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 & e) : objectWriteUInt32(this, e, t, !1), t +
			4
	}, Buffer.prototype.writeIntLE = function(e, t, r, n) {
		if (e = +e, t |= 0, !n) {
			var i = Math.pow(2, 8 * r - 1);
			checkInt(this, e, t, r, i - 1, -i)
		}
		var o = 0,
			a = 1,
			u = 0;
		for (this[t] = 255 & e; ++o < r && (a *= 256);) e < 0 && 0 === u && 0 !== this[t + o - 1] && (u = 1), this[t + o] =
			(e / a >> 0) - u & 255;
		return t + r
	}, Buffer.prototype.writeIntBE = function(e, t, r, n) {
		if (e = +e, t |= 0, !n) {
			var i = Math.pow(2, 8 * r - 1);
			checkInt(this, e, t, r, i - 1, -i)
		}
		var o = r - 1,
			a = 1,
			u = 0;
		for (this[t + o] = 255 & e; --o >= 0 && (a *= 256);) e < 0 && 0 === u && 0 !== this[t + o + 1] && (u = 1), this[t +
			o] = (e / a >> 0) - u & 255;
		return t + r
	}, Buffer.prototype.writeInt8 = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 1, 127, -128), Buffer.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)),
			e < 0 && (e = 255 + e + 1), this[t] = 255 & e, t + 1
	}, Buffer.prototype.writeInt16LE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 2, 32767, -32768), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = 255 & e,
			this[t + 1] = e >>> 8) : objectWriteUInt16(this, e, t, !0), t + 2
	}, Buffer.prototype.writeInt16BE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 2, 32767, -32768), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = e >>>
			8, this[t + 1] = 255 & e) : objectWriteUInt16(this, e, t, !1), t + 2
	}, Buffer.prototype.writeInt32LE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 4, 2147483647, -2147483648), Buffer.TYPED_ARRAY_SUPPORT ? (this[t] =
			255 & e, this[t + 1] = e >>> 8, this[t + 2] = e >>> 16, this[t + 3] = e >>> 24) : objectWriteUInt32(this, e, t, !
			0), t + 4
	}, Buffer.prototype.writeInt32BE = function(e, t, r) {
		return e = +e, t |= 0, r || checkInt(this, e, t, 4, 2147483647, -2147483648), e < 0 && (e = 4294967295 + e + 1),
			Buffer.TYPED_ARRAY_SUPPORT ? (this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 &
				e) : objectWriteUInt32(this, e, t, !1), t + 4
	}, Buffer.prototype.writeFloatLE = function(e, t, r) {
		return writeFloat(this, e, t, !0, r)
	}, Buffer.prototype.writeFloatBE = function(e, t, r) {
		return writeFloat(this, e, t, !1, r)
	}, Buffer.prototype.writeDoubleLE = function(e, t, r) {
		return writeDouble(this, e, t, !0, r)
	}, Buffer.prototype.writeDoubleBE = function(e, t, r) {
		return writeDouble(this, e, t, !1, r)
	}, Buffer.prototype.copy = function(e, t, r, n) {
		if (r || (r = 0), n || 0 === n || (n = this.length), t >= e.length && (t = e.length), t || (t = 0), n > 0 && n < r &&
			(n = r), n === r) return 0;
		if (0 === e.length || 0 === this.length) return 0;
		if (t < 0) throw new RangeError("targetStart out of bounds");
		if (r < 0 || r >= this.length) throw new RangeError("sourceStart out of bounds");
		if (n < 0) throw new RangeError("sourceEnd out of bounds");
		n > this.length && (n = this.length), e.length - t < n - r && (n = e.length - t + r);
		var i, o = n - r;
		if (this === e && r < t && t < n)
			for (i = o - 1; i >= 0; --i) e[i + t] = this[i + r];
		else if (o < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT)
			for (i = 0; i < o; ++i) e[i + t] = this[i + r];
		else Uint8Array.prototype.set.call(e, this.subarray(r, r + o), t);
		return o
	}, Buffer.prototype.fill = function(e, t, r, n) {
		if ("string" == typeof e) {
			if ("string" == typeof t ? (n = t, t = 0, r = this.length) : "string" == typeof r && (n = r, r = this.length), 1 ===
				e.length) {
				var i = e.charCodeAt(0);
				i < 256 && (e = i)
			}
			if (void 0 !== n && "string" != typeof n) throw new TypeError("encoding must be a string");
			if ("string" == typeof n && !Buffer.isEncoding(n)) throw new TypeError("Unknown encoding: " + n)
		} else "number" == typeof e && (e &= 255);
		if (t < 0 || this.length < t || this.length < r) throw new RangeError("Out of range index");
		if (r <= t) return this;
		var o;
		if (t >>>= 0, r = void 0 === r ? this.length : r >>> 0, e || (e = 0), "number" == typeof e)
			for (o = t; o < r; ++o) this[o] = e;
		else {
			var a = internalIsBuffer(e) ? e : utf8ToBytes(new Buffer(e, n).toString()),
				u = a.length;
			for (o = 0; o < r - t; ++o) this[o + t] = a[o % u]
		}
		return this
	};
	var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

	function base64clean(e) {
		if ((e = stringtrim(e).replace(INVALID_BASE64_RE, "")).length < 2) return "";
		for (; e.length % 4 != 0;) e += "=";
		return e
	}

	function stringtrim(e) {
		return e.trim ? e.trim() : e.replace(/^\s+|\s+$/g, "")
	}

	function toHex(e) {
		return e < 16 ? "0" + e.toString(16) : e.toString(16)
	}

	function utf8ToBytes(e, t) {
		var r;
		t = t || 1 / 0;
		for (var n = e.length, i = null, o = [], a = 0; a < n; ++a) {
			if ((r = e.charCodeAt(a)) > 55295 && r < 57344) {
				if (!i) {
					if (r > 56319) {
						(t -= 3) > -1 && o.push(239, 191, 189);
						continue
					}
					if (a + 1 === n) {
						(t -= 3) > -1 && o.push(239, 191, 189);
						continue
					}
					i = r;
					continue
				}
				if (r < 56320) {
					(t -= 3) > -1 && o.push(239, 191, 189), i = r;
					continue
				}
				r = 65536 + (i - 55296 << 10 | r - 56320)
			} else i && (t -= 3) > -1 && o.push(239, 191, 189);
			if (i = null, r < 128) {
				if ((t -= 1) < 0) break;
				o.push(r)
			} else if (r < 2048) {
				if ((t -= 2) < 0) break;
				o.push(r >> 6 | 192, 63 & r | 128)
			} else if (r < 65536) {
				if ((t -= 3) < 0) break;
				o.push(r >> 12 | 224, r >> 6 & 63 | 128, 63 & r | 128)
			} else {
				if (!(r < 1114112)) throw new Error("Invalid code point");
				if ((t -= 4) < 0) break;
				o.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, 63 & r | 128)
			}
		}
		return o
	}

	function asciiToBytes(e) {
		for (var t = [], r = 0; r < e.length; ++r) t.push(255 & e.charCodeAt(r));
		return t
	}

	function utf16leToBytes(e, t) {
		for (var r, n, i, o = [], a = 0; a < e.length && !((t -= 2) < 0); ++a) n = (r = e.charCodeAt(a)) >> 8, i = r % 256,
			o.push(i), o.push(n);
		return o
	}

	function base64ToBytes(e) {
		return toByteArray(base64clean(e))
	}

	function blitBuffer(e, t, r, n) {
		for (var i = 0; i < n && !(i + r >= t.length || i >= e.length); ++i) t[i + r] = e[i];
		return i
	}

	function isnan(e) {
		return e != e
	}

	function isBuffer$1(e) {
		return null != e && (!!e._isBuffer || isFastBuffer(e) || isSlowBuffer$1(e))
	}

	function isFastBuffer(e) {
		return !!e.constructor && "function" == typeof e.constructor.isBuffer && e.constructor.isBuffer(e)
	}

	function isSlowBuffer$1(e) {
		return "function" == typeof e.readFloatLE && "function" == typeof e.slice && isFastBuffer(e.slice(0, 0))
	}
	var bufferEs6 = Object.freeze({
			INSPECT_MAX_BYTES: INSPECT_MAX_BYTES,
			kMaxLength: _kMaxLength,
			Buffer: Buffer,
			SlowBuffer: SlowBuffer,
			isBuffer: isBuffer$1
		}),
		base64 = createCommonjsModule(function(e, t) {
			var r;
			r = "undefined" != typeof self ? self : "undefined" != typeof window ? window : commonjsGlobal, e.exports =
				function(t) {
					var r, n = t.Base64;
					if (e.exports)
						if ("undefined" != typeof navigator && "ReactNative" == navigator.product);
						else try {
							r = bufferEs6.Buffer
						} catch (e) {}
					var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
						o = function(e) {
							for (var t = {}, r = 0, n = e.length; r < n; r++) t[e.charAt(r)] = r;
							return t
						}(i),
						a = String.fromCharCode,
						u = function(e) {
							if (e.length < 2) {
								var t = e.charCodeAt(0);
								return t < 128 ? e : t < 2048 ? a(192 | t >>> 6) + a(128 | 63 & t) : a(224 | t >>> 12 & 15) + a(128 | t >>>
									6 & 63) + a(128 | 63 & t)
							}
							var t = 65536 + 1024 * (e.charCodeAt(0) - 55296) + (e.charCodeAt(1) - 56320);
							return a(240 | t >>> 18 & 7) + a(128 | t >>> 12 & 63) + a(128 | t >>> 6 & 63) + a(128 | 63 & t)
						},
						s = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g,
						f = function(e) {
							return e.replace(s, u)
						},
						l = function(e) {
							var t = [0, 2, 1][e.length % 3],
								r = e.charCodeAt(0) << 16 | (e.length > 1 ? e.charCodeAt(1) : 0) << 8 | (e.length > 2 ? e.charCodeAt(2) : 0),
								n = [i.charAt(r >>> 18), i.charAt(r >>> 12 & 63), t >= 2 ? "=" : i.charAt(r >>> 6 & 63), t >= 1 ? "=" : i.charAt(
									63 & r)];
							return n.join("")
						},
						c = t.btoa ? function(e) {
							return t.btoa(e)
						} : function(e) {
							return e.replace(/[\s\S]{1,3}/g, l)
						},
						d = r ? r.from && Uint8Array && r.from !== Uint8Array.from ? function(e) {
							return (e.constructor === r.constructor ? e : r.from(e)).toString("base64")
						} : function(e) {
							return (e.constructor === r.constructor ? e : new r(e)).toString("base64")
						} : function(e) {
							return c(f(e))
						},
						h = function(e, t) {
							return t ? d(String(e)).replace(/[+\/]/g, function(e) {
								return "+" == e ? "-" : "_"
							}).replace(/=/g, "") : d(String(e))
						},
						p = new RegExp(["[À-ß][-¿]", "[à-ï][-¿]{2}", "[ð-÷][-¿]{3}"].join("|"), "g"),
						_ = function(e) {
							switch (e.length) {
								case 4:
									var t = (7 & e.charCodeAt(0)) << 18 | (63 & e.charCodeAt(1)) << 12 | (63 & e.charCodeAt(2)) << 6 | 63 & e.charCodeAt(
											3),
										r = t - 65536;
									return a(55296 + (r >>> 10)) + a(56320 + (1023 & r));
								case 3:
									return a((15 & e.charCodeAt(0)) << 12 | (63 & e.charCodeAt(1)) << 6 | 63 & e.charCodeAt(2));
								default:
									return a((31 & e.charCodeAt(0)) << 6 | 63 & e.charCodeAt(1))
							}
						},
						m = function(e) {
							return e.replace(p, _)
						},
						y = function(e) {
							var t = e.length,
								r = t % 4,
								n = (t > 0 ? o[e.charAt(0)] << 18 : 0) | (t > 1 ? o[e.charAt(1)] << 12 : 0) | (t > 2 ? o[e.charAt(2)] << 6 :
									0) | (t > 3 ? o[e.charAt(3)] : 0),
								i = [a(n >>> 16), a(n >>> 8 & 255), a(255 & n)];
							return i.length -= [0, 0, 2, 1][r], i.join("")
						},
						g = t.atob ? function(e) {
							return t.atob(e)
						} : function(e) {
							return e.replace(/[\s\S]{1,4}/g, y)
						},
						b = r ? r.from && Uint8Array && r.from !== Uint8Array.from ? function(e) {
							return (e.constructor === r.constructor ? e : r.from(e, "base64")).toString()
						} : function(e) {
							return (e.constructor === r.constructor ? e : new r(e, "base64")).toString()
						} : function(e) {
							return m(g(e))
						},
						v = function(e) {
							return b(String(e).replace(/[-_]/g, function(e) {
								return "-" == e ? "+" : "/"
							}).replace(/[^A-Za-z0-9\+\/]/g, ""))
						};
					if (t.Base64 = {
							VERSION: "2.4.8",
							atob: g,
							btoa: c,
							fromBase64: v,
							toBase64: h,
							utob: f,
							encode: h,
							encodeURI: function(e) {
								return h(e, !0)
							},
							btou: m,
							decode: v,
							noConflict: function() {
								var e = t.Base64;
								return t.Base64 = n, e
							}
						}, "function" == typeof Object.defineProperty) {
						var A = function(e) {
							return {
								value: e,
								enumerable: !1,
								writable: !0,
								configurable: !0
							}
						};
						t.Base64.extendString = function() {
							Object.defineProperty(String.prototype, "fromBase64", A(function() {
								return v(this)
							})), Object.defineProperty(String.prototype, "toBase64", A(function(e) {
								return h(this, e)
							})), Object.defineProperty(String.prototype, "toBase64URI", A(function() {
								return h(this, !0)
							}))
						}
					}
					return t.Meteor && (Base64 = t.Base64), e.exports && (e.exports.Base64 = t.Base64), {
						Base64: t.Base64
					}
				}(r)
		}),
		base64_1 = base64.Base64;
	class WatchStat {
		constructor(e) {
			this.set = e, this.statistics = null, this.timeCountInterval = null, this.currentTime = 0, this.recordCurrentTime =
				0, this.playDuration = 0, this.PLAY_TYPE = {
					PLAY: "PLAY",
					PAUSE: "PAUSE"
				}, this.playStat = this.PLAY_TYPE.PAUSE, this.sendTimeStamp = Date.now(), this.isFirstSendLog = !0, this.initStatistics()
		}
		start() {
			this.stop(), this.timeCountInterval = setInterval(() => {
				this.recordCurrentTime !== this.currentTime ? (this.recordCurrentTime = this.currentTime, this.playStat = this.PLAY_TYPE
					.PLAY, this.playDuration++, this.send()) : this.playStat = this.PLAY_TYPE.PAUSE
			}, 1e3)
		}
		initStatistics() {
			const {
				sid: e,
				params: t,
				viewerInfo: r
			} = this.set;
			this.statistics = {
				sid: this.base64(r.viewerId || e),
				param1: this.base64(t.param1),
				param2: this.base64(r.viewerName || t.param2),
				param3: this.base64(t.param3),
				param4: this.base64(t.param4),
				param5: this.base64(t.param5)
			}
		}
		timeUpdate(e) {
			const {
				useAudio: t
			} = this.set;
			t ? this.currentTime = e : e && e.detail && e.detail.currentTime && (this.currentTime = e.detail.currentTime)
		}
		j2s_realPlayStatus() {
			const {
				playDuration: e
			} = this, {
				pid: t,
				vid: r
			} = this.set;
			return {
				playDuration: e,
				pid: t,
				vid: r
			}
		}
		send() {
			const e = Date.now(),
				{
					sendTimeStamp: t,
					playStat: r,
					PLAY_TYPE: n,
					playDuration: i,
					currentTime: o
				} = this,
				{
					pid: a,
					vid: u,
					uid: s,
					duration: f,
					sid: l,
					params: c,
					version: d,
					viewerInfo: h
				} = this.set;
			if (e - t < 1e4 || r !== n.PLAY && i <= 0) return;
			this.sendTimeStamp = e;
			const p = Math.floor(o),
				_ = {
					pid: a,
					vid: u,
					uid: s,
					flow: 0,
					pd: i,
					sd: i,
					cts: p,
					duration: f,
					pn: "webapp_vod",
					pv: d,
					sign: md5(`rtas.net${a}${u}0${i}${p}`),
					ts: e
				};
			Object.assign(_, this.statistics), this.isFirstSendLog && (this.isFirstSendLog = !1, _.ute = "bop", _.viewerAvatar =
				this.base64(h.viewerAvatar)), ajxa.request("https://prtas.videocc.net/v2/view", "GET", _)
		}
		base64(e) {
			return e ? base64_1.encode(e) : ""
		}
		stop() {
			this.timeCountInterval && (clearInterval(this.timeCountInterval), this.timeCountInterval = null), this.playDuration =
				0
		}
	}
	class Player {
		constructor(e) {
			this.set = Object.assign({
				params: {},
				viewerInfo: {}
			}, e), this.data = {}, this.errorPanel = null, this.jsonLoad = null, this.watchStat = null, this.init()
		}
		async init() {
			this.initModule();
			const {
				vid: e
			} = this.set;
			if (!e) return this.errorPanel.emit(1001);
			this.initId(), await this.loadJson(), this.result(), this.sendStats()
		}
		initId() {
			const e = `${Date.now()}X${Math.floor(1e6*Math.random()+1e6)}`;
			this.set.pid = e, this.set.uid = this.set.vid.substring(0, 10)
		}
		initModule() {
			this.errorPanel = new ErrorPanel(this.set), this.jsonLoad = new JsonLoad(this.set), this.watchStat = new WatchStat(
				this.set)
		}
		async loadJson() {
			this.data = await this.jsonLoad.getVodJson(), this.set.duration = parseInt(this.data.duration)
		}
		result() {
			const {
				outflow: e,
				timeoutflow: t
			} = this.data, {
				callback: r
			} = this.set;
			return "true" === e ? this.errorPanel.emit(1002) : "true" === t ? this.errorPanel.emit(1003) : (this.data.type =
				"success", void(r && r(this.data)))
		}
		sendStats() {
			this.watchStat.start()
		}
		timeUpdate(e) {
			this.watchStat.timeUpdate(e)
		}
		destroy() {
			this.watchStat.stop()
		}
		j2s_realPlayStatus() {
			return this.watchStat.j2s_realPlayStatus()
		}
	}
	const polyvVodePlayer = {
		version: "v1.10.0",
		buidMetaData: 20200527,
		getVideo(e) {
			return e.version = this.version, new Player(e)
		},
		getPreviewVideo(e) {
			return e.isPreviewMode = !0, e.version = this.version, new Player(e)
		}
	};
	return polyvVodePlayer
});
